#include <Spell.hpp>

Inheritance diagram for Spell:

Collaboration diagram for Spell:

Classes
struct	HitAuraEffect

struct	HitSpellEffect

struct	MissSpellEffect

Public Member Functions
	Spell (Object _caster, SpellInfo const _spellInfo, bool _triggered, Aura *_aura)

	~Spell ()

SpellCastResult	prepare (SpellCastTargets *targets)

void	castMe (const bool doReCheck)

void	handleHittedTarget (const uint64_t targetGuid, uint8_t effIndex)

void	handleHittedEffect (const uint64_t targetGuid, uint8_t effIndex, int32_t effDamage, bool reCheckTarget=false)

void	handleMissedTarget (SpellTargetMod const missedTarget)

void	handleMissedEffect (SpellTargetMod const missedTarget, bool reCheckTarget=false)

void	finish (bool successful=true)

void	update (unsigned long timePassed)

void	cancel ()

int32_t	calculateEffect (uint8_t effIndex)

void	calculateJumpSpeeds (Unit unitCaster, SpellInfo const spellInfo, uint8_t i, float dist, float &speedXY, float &speedZ)

virtual SpellCastResult	canCast (const bool secondCheck, uint32_t parameter1, uint32_t parameter2)

SpellCastResult	checkPower ()

void	sendCastResult (SpellCastResult result, uint32_t parameter1=0, uint32_t parameter2=0)

void	sendChannelUpdate (const uint32_t time, const uint32_t diff=0)

int32_t	getFullCastTime () const

int32_t	getCastTimeLeft () const

uint32_t	getPowerCost () const

Object *	getCaster () const

Unit *	getUnitCaster () const

Player *	getPlayerCaster () const

GameObject *	getGameObjectCaster () const

Item *	getItemCaster () const

void	setItemCaster (Item *itemCaster)

bool	wasCastedinDuel () const

bool	hasTarget (const uint64_t &_guid, std::vector< uint64_t > *tmpGuidMap)

Item *	getItemTarget () const

void	setUnitTarget (Unit *_unit)

Unit *	getUnitTarget () const

Player *	getPlayerTarget () const

GameObject *	getGameObjectTarget () const

Corpse *	getCorpseTarget () const

void	unsetAllTargets ()

void	setTargetConstraintCreature (Creature *_creature)

Creature *	getTargetConstraintCreature () const

void	setTargetConstraintGameObject (GameObject *_gameobject)

GameObject *	getTargetConstraintGameObject () const

LocationVector	getDestination ()

LocationVector	getSource ()

SpellInfo const *	getSpellInfo () const

bool	hasAttribute (SpellAttributes _attribute) const

bool	hasAttributeEx (SpellAttributesEx _attribute) const

bool	hasAttributeExB (SpellAttributesExB _attribute) const

bool	hasAttributeExC (SpellAttributesExC _attribute) const

bool	hasAttributeExD (SpellAttributesExD _attribute) const

bool	hasAttributeExE (SpellAttributesExE _attribute) const

bool	hasAttributeExF (SpellAttributesExF _attribute) const

bool	hasAttributeExG (SpellAttributesExG _attribute) const

void	resetSpellInfoOverride ()

Aura *	getTriggeredByAura () const

int8_t	getUsedComboPoints () const

void	addUsedSpellModifier (AuraEffectModifier const *aurEff)

void	removeUsedSpellModifier (AuraEffectModifier const *aurEff)

void	takeUsedSpellModifiers ()

void	setForceCritOnTarget (Unit const *target)

int32_t	getDuration ()

float_t	getEffectRadius (uint8_t effectIndex)

void	spellEffectNotImplemented (uint8_t effectIndex)

void	spellEffectNotUsed (uint8_t effectIndex)

void	spellEffectInstantKill (uint8_t effectIndex)

void	spellEffectSchoolDMG (uint8_t effectIndex)

void	spellEffectDummy (uint8_t effectIndex)

void	spellEffectTeleportUnits (uint8_t effectIndex)

void	spellEffectApplyAura (uint8_t effectIndex)

void	spellEffectEnvironmentalDamage (uint8_t effectIndex)

void	spellEffectPowerDrain (uint8_t effectIndex)

void	spellEffectHealthLeech (uint8_t effectIndex)

void	spellEffectHeal (uint8_t effectIndex)

void	spellEffectBind (uint8_t effectIndex)

void	spellEffectQuestComplete (uint8_t effectIndex)

void	spellEffectWeapondamageNoschool (uint8_t effectIndex)

void	spellEffectResurrect (uint8_t effectIndex)

void	spellEffectAddExtraAttacks (uint8_t effectIndex)

void	spellEffectDodge (uint8_t effectIndex)

void	spellEffectParry (uint8_t effectIndex)

void	spellEffectBlock (uint8_t effectIndex)

void	spellEffectCreateItem (uint8_t effectIndex)

void	spellEffectWeapon (uint8_t effectIndex)

void	spellEffectDefense (uint8_t effectIndex)

void	spellEffectPersistentAA (uint8_t effectIndex)

void	spellEffectSummon (uint8_t effectIndex)

void	spellEffectSummonWild (uint8_t effectIndex)

void	spellEffectSummonGuardian (uint8_t effectIndex, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	spellEffectSummonTemporaryPet (uint8_t effectIndex, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	spellEffectSummonTotem (uint8_t effectIndex, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties, LocationVector &v)

void	spellEffectSummonPossessed (uint8_t effectIndex, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	spellEffectSummonCompanion (uint8_t effectIndex, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	spellEffectSummonVehicle (uint8_t effectIndex, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	spellEffectLeap (uint8_t effectIndex)

void	spellEffectEnergize (uint8_t effectIndex)

void	spellEffectWeaponDmgPerc (uint8_t effectIndex)

void	spellEffectTriggerMissile (uint8_t effectIndex)

void	spellEffectOpenLock (uint8_t effectIndex)

void	spellEffectTransformItem (uint8_t effectIndex)

void	spellEffectApplyGroupAA (uint8_t effectIndex)

void	spellEffectLearnSpell (uint8_t effectIndex)

void	spellEffectSpellDefense (uint8_t effectIndex)

void	spellEffectDispel (uint8_t effectIndex)

void	spellEffectDualWield (uint8_t effectIndex)

void	spellEffectSkillStep (uint8_t effectIndex)

void	spellEffectAddHonor (uint8_t effectIndex)

void	spellEffectSpawn (uint8_t effectIndex)

void	spellEffectSummonObject (uint8_t effectIndex)

void	spellEffectEnchantItem (uint8_t effectIndex)

void	spellEffectEnchantItemTemporary (uint8_t effectIndex)

void	spellEffectTameCreature (uint8_t effectIndex)

void	spellEffectSummonPet (uint8_t effectIndex)

void	spellEffectLearnPetSpell (uint8_t effectIndex)

void	spellEffectWeapondamage (uint8_t effectIndex)

void	spellEffectOpenLockItem (uint8_t effectIndex)

void	spellEffectProficiency (uint8_t effectIndex)

void	spellEffectSendEvent (uint8_t effectIndex)

void	spellEffectPowerBurn (uint8_t effectIndex)

void	spellEffectThreat (uint8_t effectIndex)

void	spellEffectClearQuest (uint8_t effectIndex)

void	spellEffectForceCast (uint8_t effectIndex)

void	spellEffectTriggerSpell (uint8_t effectIndex)

void	spellEffectApplyRaidAA (uint8_t effectIndex)

void	spellEffectPowerFunnel (uint8_t effectIndex)

void	spellEffectHealMaxHealth (uint8_t effectIndex)

void	spellEffectInterruptCast (uint8_t effectIndex)

void	spellEffectDistract (uint8_t effectIndex)

void	spellEffectPickpocket (uint8_t effectIndex)

void	spellEffectAddFarsight (uint8_t effectIndex)

void	spellEffectUseGlyph (uint8_t effectIndex)

void	spellEffectHealMechanical (uint8_t effectIndex)

void	spellEffectSummonObjectWild (uint8_t effectIndex)

void	spellEffectScriptEffect (uint8_t effectIndex)

void	spellEffectSanctuary (uint8_t effectIndex)

void	spellEffectAddComboPoints (uint8_t effectIndex)

void	spellEffectCreateHouse (uint8_t effectIndex)

void	spellEffectDuel (uint8_t effectIndex)

void	spellEffectStuck (uint8_t effectIndex)

void	spellEffectSummonPlayer (uint8_t effectIndex)

void	spellEffectActivateObject (uint8_t effectIndex)

void	spellEffectBuildingDamage (uint8_t effectIndex)

void	spellEffectEnchantHeldItem (uint8_t effectIndex)

void	spellEffectSetMirrorName (uint8_t effectIndex)

void	spellEffectSelfResurrect (uint8_t effectIndex)

void	spellEffectSkinning (uint8_t effectIndex)

void	spellEffectCharge (uint8_t effectIndex)

void	spellEffectKnockBack (uint8_t effectIndex)

void	spellEffectKnockBack2 (uint8_t effectIndex)

void	spellEffectDisenchant (uint8_t effectIndex)

void	spellEffectInebriate (uint8_t effectIndex)

void	spellEffectFeedPet (uint8_t effectIndex)

void	spellEffectDismissPet (uint8_t effectIndex)

void	spellEffectReputation (uint8_t effectIndex)

void	spellEffectSummonObjectSlot (uint8_t effectIndex)

void	spellEffectDispelMechanic (uint8_t effectIndex)

void	spellEffectSummonDeadPet (uint8_t effectIndex)

void	spellEffectDestroyAllTotems (uint8_t effectIndex)

void	spellEffectDurabilityDamage (uint8_t effectIndex)

void	spellEffectDurabilityDamagePCT (uint8_t effectIndex)

void	spellEffectResurrectNew (uint8_t effectIndex)

void	spellEffectAttackMe (uint8_t effectIndex)

void	spellEffectSkinPlayerCorpse (uint8_t effectIndex)

void	spellEffectSkill (uint8_t effectIndex)

void	spellEffectApplyPetAA (uint8_t effectIndex)

void	spellEffectDummyMelee (uint8_t effectIndex)

void	spellEffectStartTaxi (uint8_t effectIndex)

void	spellEffectPlayerPull (uint8_t effectIndex)

void	spellEffectReduceThreatPercent (uint8_t effectIndex)

void	spellEffectSpellSteal (uint8_t effectIndex)

void	spellEffectProspecting (uint8_t effectIndex)

void	spellEffectApplyFriendAA (uint8_t effectIndex)

void	spellEffectApplyEnemyAA (uint8_t effectIndex)

void	spellEffectRedirectThreat (uint8_t effectIndex)

void	spellEffectPlayMusic (uint8_t effectIndex)

void	spellEffectForgetSpecialization (uint8_t effectIndex)

void	spellEffectKillCredit (uint8_t effectIndex)

void	spellEffectRestorePowerPct (uint8_t effectIndex)

void	spellEffectTriggerSpellWithValue (uint8_t effectIndex)

void	spellEffectApplyOwnerAA (uint8_t effectIndex)

void	spellEffectCreatePet (uint8_t effectIndex)

void	spellEffectTeachTaxiPath (uint8_t effectIndex)

void	spellEffectDualWield2H (uint8_t effectIndex)

void	spellEffectEnchantItemPrismatic (uint8_t effectIndex)

void	spellEffectCreateItem2 (uint8_t effectIndex)

void	spellEffectMilling (uint8_t effectIndex)

void	spellEffectRenamePet (uint8_t effectIndex)

void	spellEffectRestoreHealthPct (uint8_t effectIndex)

void	spellEffectLearnSpec (uint8_t effectIndex)

void	spellEffectActivateSpec (uint8_t effectIndex)

void	spellEffectActivateRunes (uint8_t effectIndex)

void	spellEffectJumpTarget (uint8_t effectIndex)

void	spellEffectJumpBehindTarget (uint8_t effectIndex)

void	FillSpecifiedTargetsInArea (float srcx, float srcy, float srcz, uint32_t ind, uint32_t specification)

void	FillSpecifiedTargetsInArea (uint32_t i, float srcx, float srcy, float srcz, float range, uint32_t specification)

void	FillAllTargetsInArea (uint32_t i, float srcx, float srcy, float srcz, float range)

void	FillAllTargetsInArea (float srcx, float srcy, float srcz, uint32_t ind)

void	FillAllTargetsInArea (LocationVector &location, uint32_t ind)

void	FillAllFriendlyInArea (uint32_t i, float srcx, float srcy, float srcz, float range)

uint64_t	GetSinglePossibleEnemy (uint32_t i, float prange=0)

uint64_t	GetSinglePossibleFriend (uint32_t i, float prange=0)

bool	GenerateTargets (SpellCastTargets *store_buff)

void	FillTargetMap (uint32_t)

void	HandleTargetNoObject ()

uint8_t	DidHit (uint32_t effindex, Unit *target)

void	castMeOld ()

uint8_t	CanCast (bool)

void	HandleTeleport (LocationVector position, uint32_t mapid, Unit *Target)

void	DetermineSkillUp ()

void	AddTime (uint32_t type)

uint32_t	getState () const

void	SendLogExecute (uint32_t damage, uint64_t &targetGuid)

void	SendInterrupted (uint8_t result)

void	SendResurrectRequest (Player *target)

void	SendTameFailure (uint8_t failure)

void	HandleAddAura (uint64_t guid)

void	CreateItem (uint32_t itemId)

void	ApplyAreaAura (uint8_t effectIndex)

void	SpellEffectInstantKill (uint8_t effectIndex)

void	SpellEffectSchoolDMG (uint8_t effectIndex)

void	SpellEffectTeleportUnits (uint8_t effectIndex)

void	SpellEffectApplyAura (uint8_t effectIndex)

void	SpellEffectEnvironmentalDamage (uint8_t effectIndex)

void	SpellEffectPowerDrain (uint8_t effectIndex)

void	SpellEffectHeal (uint8_t effectIndex)

void	SpellEffectBind (uint8_t effectIndex)

void	SpellEffectQuestComplete (uint8_t effectIndex)

void	SpellEffectWeapondamageNoschool (uint8_t effectIndex)

void	SpellEffectResurrect (uint8_t effectIndex)

void	SpellEffectAddExtraAttacks (uint8_t effectIndex)

void	SpellEffectDodge (uint8_t effectIndex)

void	SpellEffectParry (uint8_t effectIndex)

void	SpellEffectBlock (uint8_t effectIndex)

void	SpellEffectCreateItem (uint8_t effectIndex)

void	SpellEffectPersistentAA (uint8_t effectIndex)

virtual void	SpellEffectSummon (uint8_t effectIndex)

void	SpellEffectSummonWild (uint8_t effectIndex)

void	SpellEffectSummonGuardian (uint32_t i, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	SpellEffectSummonTemporaryPet (uint32_t i, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	SpellEffectSummonPossessed (uint32_t i, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	SpellEffectSummonCompanion (uint32_t i, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	SpellEffectSummonVehicle (uint32_t i, WDB::Structures::SummonPropertiesEntry const spe, CreatureProperties const properties_, LocationVector &v)

void	SpellEffectLeap (uint8_t effectIndex)

void	SpellEffectEnergize (uint8_t effectIndex)

void	SpellEffectWeaponDmgPerc (uint8_t effectIndex)

void	SpellEffectTriggerMissile (uint8_t effectIndex)

void	SpellEffectOpenLock (uint8_t effectIndex)

void	SpellEffectTransformItem (uint8_t effectIndex)

void	SpellEffectApplyGroupAA (uint8_t effectIndex)

void	SpellEffectLearnSpell (uint8_t effectIndex)

void	SpellEffectSpellDefense (uint8_t effectIndex)

void	SpellEffectDispel (uint8_t effectIndex)

void	SpellEffectAddHonor (uint8_t effectIndex)

void	SpellEffectSpawn (uint8_t effectIndex)

void	SpellEffectSummonObject (uint8_t effectIndex)

void	SpellEffectEnchantItem (uint8_t effectIndex)

void	SpellEffectEnchantItemTemporary (uint8_t effectIndex)

void	SpellEffectTameCreature (uint8_t effectIndex)

void	SpellEffectSummonPet (uint8_t effectIndex)

void	SpellEffectLearnPetSpell (uint8_t effectIndex)

void	SpellEffectWeapondamage (uint8_t effectIndex)

void	SpellEffectOpenLockItem (uint8_t effectIndex)

void	SpellEffectSendEvent (uint8_t effectIndex)

void	SpellEffectPowerBurn (uint8_t effectIndex)

void	SpellEffectThreat (uint8_t effectIndex)

void	SpellEffectClearQuest (uint8_t effectIndex)

void	SpellEffectApplyRaidAA (uint8_t effectIndex)

void	SpellEffectPowerFunnel (uint8_t effectIndex)

void	SpellEffectHealMaxHealth (uint8_t effectIndex)

void	SpellEffectInterruptCast (uint8_t effectIndex)

void	SpellEffectDistract (uint8_t effectIndex)

void	SpellEffectPickpocket (uint8_t effectIndex)

void	SpellEffectAddFarsight (uint8_t effectIndex)

void	SpellEffectUseGlyph (uint8_t effectIndex)

void	SpellEffectHealMechanical (uint8_t effectIndex)

void	SpellEffectSummonObjectWild (uint8_t effectIndex)

void	SpellEffectSanctuary (uint8_t effectIndex)

void	SpellEffectAddComboPoints (uint8_t effectIndex)

void	SpellEffectCreateHouse (uint8_t effectIndex)

void	SpellEffectDuel (uint8_t effectIndex)

void	SpellEffectStuck (uint8_t effectIndex)

void	SpellEffectSummonPlayer (uint8_t effectIndex)

void	SpellEffectActivateObject (uint8_t effectIndex)

void	SpellEffectBuildingDamage (uint8_t effectIndex)

void	SpellEffectEnchantHeldItem (uint8_t effectIndex)

void	SpellEffectForceDeselect (uint8_t effectIndex)

void	SpellEffectSelfResurrect (uint8_t effectIndex)

void	SpellEffectSkinning (uint8_t effectIndex)

void	SpellEffectCharge (uint8_t effectIndex)

void	SpellEffectKnockBack (uint8_t effectIndex)

void	SpellEffectKnockBack2 (uint8_t effectIndex)

void	SpellEffectPullTowardsDest (uint8_t effectIndex)

void	SpellEffectDisenchant (uint8_t effectIndex)

void	SpellEffectInebriate (uint8_t effectIndex)

void	SpellEffectFeedPet (uint8_t effectIndex)

void	SpellEffectDismissPet (uint8_t effectIndex)

void	SpellEffectReputation (uint8_t effectIndex)

void	SpellEffectSummonObjectSlot (uint8_t effectIndex)

void	SpellEffectDispelMechanic (uint8_t effectIndex)

void	SpellEffectSummonDeadPet (uint8_t effectIndex)

void	SpellEffectDestroyAllTotems (uint8_t effectIndex)

void	SpellEffectDurabilityDamage (uint8_t effectIndex)

void	SpellEffectDurabilityDamagePCT (uint8_t effectIndex)

void	SpellEffectResurrectNew (uint8_t effectIndex)

void	SpellEffectAttackMe (uint8_t effectIndex)

void	SpellEffectSkinPlayerCorpse (uint8_t effectIndex)

void	SpellEffectApplyPetAA (uint8_t effectIndex)

void	SpellEffectDummyMelee (uint8_t effectIndex)

void	SpellEffectStartTaxi (uint8_t effectIndex)

void	SpellEffectPlayerPull (uint8_t effectIndex)

void	SpellEffectReduceThreatPercent (uint8_t effectIndex)

void	SpellEffectSpellSteal (uint8_t effectIndex)

void	SpellEffectProspecting (uint8_t effectIndex)

void	SpellEffectApplyFriendAA (uint8_t effectIndex)

void	SpellEffectApplyEnemyAA (uint8_t effectIndex)

void	SpellEffectRedirectThreat (uint8_t effectIndex)

void	SpellEffectPlayMusic (uint8_t effectIndex)

void	SpellEffectForgetSpecialization (uint8_t effectIndex)

void	SpellEffectKillCredit (uint8_t effectIndex)

void	SpellEffectRestorePowerPct (uint8_t effectIndex)

void	SpellEffectTriggerSpellWithValue (uint8_t effectIndex)

void	SpellEffectApplyOwnerAA (uint8_t effectIndex)

void	SpellEffectCreatePet (uint8_t effectIndex)

void	SpellEffectTeachTaxiPath (uint8_t effectIndex)

void	SpellEffectDualWield2H (uint8_t effectIndex)

void	SpellEffectEnchantItemPrismatic (uint8_t effectIndex)

void	SpellEffectCreateItem2 (uint8_t effectIndex)

void	SpellEffectMilling (uint8_t effectIndex)

void	SpellEffectRenamePet (uint8_t effectIndex)

void	SpellEffectRestoreHealthPct (uint8_t effectIndex)

void	SpellEffectLearnSpec (uint8_t effectIndex)

void	SpellEffectActivateSpec (uint8_t effectIndex)

void	SpellEffectActivateRunes (uint8_t effectIndex)

void	SpellEffectJumpTarget (uint8_t effectIndex)

void	SpellEffectJumpBehindTarget (uint8_t effectIndex)

uint32_t	GetType ()

bool	IsAspect ()

bool	IsSeal ()

void	InitProtoOverride ()

bool	IsStealthSpell ()

bool	IsInvisibilitySpell ()

bool	DuelSpellNoMoreValid () const

bool	GetSpellFailed () const

void	SetSpellFailed (bool failed=true)

void	SafeAddTarget (std::vector< uint64_t > *tgt, uint64_t guid)

void	DetermineSkillUp (uint16_t skillid, uint32_t targetlevel, uint32_t multiplicator=1)

void	DetermineSkillUp (uint16_t skillid)

bool	AddTarget (uint32_t i, uint32_t TargetType, Object *obj)

void	AddAOETargets (uint32_t i, uint32_t TargetType, float r, uint32_t maxtargets)

void	AddPartyTargets (uint32_t i, uint32_t TargetType, float r, uint32_t maxtargets)

void	AddRaidTargets (uint32_t i, uint32_t TargetType, float r, uint32_t maxtargets, bool partylimit=false)

void	AddChainTargets (uint32_t i, uint32_t TargetType, float r, uint32_t maxtargets)

void	AddConeTargets (uint32_t i, uint32_t TargetType, float r, uint32_t maxtargets)

void	AddScriptedOrSpellFocusTargets (uint32_t i, uint32_t TargetType, float r, uint32_t maxtargets)

Static Public Member Functions
static uint32_t	GetBaseThreat (uint32_t dmg)

static uint32_t	GetMechanic (SpellInfo const *sp)

Public Attributes
std::shared_ptr< SpellForcedBasePoints >	forced_basepoints

uint32_t	pSpellId

SpellInfo const *	ProcedOnSpell

SpellCastTargets	m_targets

uint32_t	chaindamage

int32_t	damage

bool	m_AreaAura

int32_t	m_charges

int32_t	damageToHit

uint32_t	castedItemId

uint8_t	extra_cast_number

uint32_t	m_glyphslot

float	m_missilePitch

uint32_t	m_missileTravelTime

Protected Member Functions
virtual int32_t	DoCalculateEffect (uint32_t i, Unit *target, int32_t value)

virtual void	DoAfterHandleEffect (Unit *target, uint32_t i)

Protected Attributes
float_t	m_castPositionX = 0.0f

float_t	m_castPositionY = 0.0f

float_t	m_castPositionZ = 0.0f

float_t	m_castPositionO = 0.0f

bool	duelSpell = false

Object *	m_caster = nullptr

Unit *	u_caster = nullptr

Player *	p_caster = nullptr

GameObject *	g_caster = nullptr

Item *	i_caster = nullptr

Creature *	m_targetConstraintCreature = nullptr

GameObject *	m_targetConstraintGameObject = nullptr

SpellTargetConstraint const *	m_targetConstraint

bool	m_Spell_Failed
	Spell state's.

bool	m_Delayed

uint8_t	m_DelayStep

bool	m_IsCastedOnSelf

uint64_t	m_magnetTarget

uint32_t	add_damage

uint8_t	m_rune_avail_before

Private Member Functions
SpellCastResult	checkItems (uint32_t parameter1, uint32_t parameter2) const

SpellCastResult	checkCasterState () const

SpellCastResult	checkRange (const bool secondCheck)

SpellCastResult	checkRunes (bool takeRunes)

SpellCastResult	checkShapeshift (SpellInfo const *spellInfo, const uint32_t shapeshiftForm) const

void	sendSpellStart ()

void	sendSpellGo ()

void	sendChannelStart (const uint32_t duration)

void	sendCastResult (Player *caster, uint8_t castCount, SpellCastResult result, uint32_t parameter1, uint32_t parameter2)

void	writeProjectileDataToPacket (WorldPacket *data)

void	writeSpellMissedTargets (WorldPacket *data)

void	takePower ()

uint32_t	calculatePowerCost ()

SpellCastResult	checkExplicitTarget (Object *target, uint32_t requiredTargetMask) const

void	safeAddMissedTarget (uint64_t targetGuid, SpellDidHitResult hitResult, SpellDidHitResult extendedHitResult)

bool	canAttackCreatureType (Creature *target) const

void	removeCastItem ()

void	removeReagents ()

void	_updateCasterPointers (Object *caster)

void	_updateTargetPointers (const uint64_t targetGuid)

void	_loadInitialTargetPointers (bool reset=false)

float_t	_getSpellTravelTimeForTarget (uint64_t guid) const

void	_prepareProcFlags ()

Private Attributes
int32_t	m_castTime = 0

int32_t	m_timer = 0

uint32_t	m_powerCost = 0

bool	m_usesMana = false

std::vector< SpellUniqueTarget >	m_uniqueHittedTargets

std::vector< SpellTargetMod >	m_missedTargets

std::vector< uint64_t >	m_effectTargets [MAX_SPELL_EFFECTS]

Unit *	m_unitTarget = nullptr

Item *	m_itemTarget = nullptr

GameObject *	m_gameObjTarget = nullptr

Player *	m_playerTarget = nullptr

Corpse *	m_corpseTarget = nullptr

SpellInfo const *	m_spellInfo = nullptr

SpellInfo const *	m_spellInfo_override = nullptr

bool	m_canBeReflected = false

bool	m_requiresCP = false

int8_t	m_usedComboPoints = 0

int32_t	m_duration = 0

bool	isDurationSet = false

float_t	m_effectRadius [MAX_SPELL_EFFECTS] = { 0.0f }

bool	m_isEffectRadiusSet [MAX_SPELL_EFFECTS] = { false }

DamageInfo	m_casterDamageInfo = DamageInfo()

DamageInfo	m_targetDamageInfo = DamageInfo()

bool	isTargetDamageInfoSet = false

uint32_t	m_casterProcFlags = 0

uint32_t	m_targetProcFlags = 0

std::set< uint64_t >	m_doneTargetProcs

std::map< uint64_t, HitAuraEffect >	m_pendingAuras

std::map< uint64_t, HitSpellEffect >	m_hitEffects

std::map< uint64_t, MissSpellEffect >	m_missEffects

std::vector< uint64_t >	m_critTargets

bool	isForcedCrit = false

bool	isEffectDamageStatic [MAX_SPELL_EFFECTS]

float_t	effectPctModifier [MAX_SPELL_EFFECTS]

std::map< AuraEffectModifier const *, bool >	m_usedModifiers

SpellState	m_spellState = SPELL_STATE_NULL

SpellCastResult	cancastresult = SPELL_CAST_SUCCESS

bool	m_triggeredSpell = false

Aura *	m_triggeredByAura = nullptr

Friends
class	DummySpellHandler

class	DynamicObject

Detailed Description

Definition at line 52 of file Spell.hpp.

Constructor & Destructor Documentation

◆ Spell()

Spell::Spell	(	Object *	_caster,
		SpellInfo const *	_spellInfo,
		bool	_triggered,
		Aura *	_aura
	)

Definition at line 75 of file Spell.cpp.

{
    if (_caster == nullptr)
    {
        sLogger.failure("Spell::Spell cant initialize without caster!");
        return;
    }
 
    if (_spellInfo == nullptr)
    {
        sLogger.failure("Spell::Spell cant initialize without valid spell info!");
        return;
    }
 
    _caster->m_pendingSpells.insert(this);
    chaindamage = 0;
    damage = 0;
 
    m_DelayStep = 0;
 
    m_AreaAura = false;
 
    damageToHit = 0;
    castedItemId = 0;
 
    m_Spell_Failed = false;
 
    add_damage = 0;
    m_Delayed = false;
    pSpellId = 0;
    ProcedOnSpell = nullptr;
    extra_cast_number = 0;
    m_glyphslot = 0;
    m_charges = _spellInfo->getProcCharges();
 
    // create rune avail snapshot
    if (p_caster && p_caster->isClassDeathKnight())
        m_rune_avail_before = static_cast<DeathKnight*>(p_caster)->GetRuneFlags();
    else
        m_rune_avail_before = 0;
 
    m_targetConstraint = sSpellMgr.getSpellTargetConstraintForSpell(_spellInfo->getId());
 
    m_missilePitch = 0;
    m_missileTravelTime = 0;
    m_IsCastedOnSelf = false;
    m_magnetTarget = 0;
 
    m_spellInfo = _spellInfo;
 
    // Get spell difficulty
    if (_spellInfo->getSpellDifficultyID() != 0 && !_caster->isPlayer() && _caster->getWorldMap() != nullptr)
    {
        auto SpellDiffEntry = sSpellMgr.getSpellInfoByDifficulty(_spellInfo->getSpellDifficultyID(), _caster->getWorldMap()->getDifficulty());
        if (SpellDiffEntry != nullptr)
            m_spellInfo = SpellDiffEntry;
    }
 
    // Initialize caster pointers
    _updateCasterPointers(_caster);
 
    // Check if spell is casted in a duel
    switch (_caster->getObjectTypeId())
    {
    case TYPEID_PLAYER:
    case TYPEID_UNIT:
        if (u_caster && u_caster->getPlayerOwnerOrSelf() != nullptr && u_caster->getPlayerOwnerOrSelf()->getDuelState() == DUEL_STATE_STARTED)
            duelSpell = true;
        break;
    case TYPEID_ITEM:
    case TYPEID_CONTAINER:
        if (i_caster->getOwner() != nullptr && i_caster->getOwner()->getDuelState() == DUEL_STATE_STARTED)
            duelSpell = true;
        break;
    case TYPEID_GAMEOBJECT:
        if (g_caster->getPlayerOwner() != nullptr && g_caster->getPlayerOwner()->getDuelState() == DUEL_STATE_STARTED)
            duelSpell = true;
        break;
    default:
        break;
    }
 
    if (u_caster && getSpellInfo()->getAttributesExF() & ATTRIBUTESEXF_CAST_BY_CHARMER)
    {
        const auto unitCharmer = u_caster->getWorldMapUnit(u_caster->getCharmedByGuid());
        if (unitCharmer != nullptr)
        {
            u_caster = unitCharmer;
            if (unitCharmer->isPlayer())
                p_caster = dynamic_cast<Player*>(unitCharmer);
        }
    }
 
    m_triggeredSpell = _triggered;
    m_triggeredByAura = _aura;
    if (getSpellInfo()->getAttributesExD() & ATTRIBUTESEXD_TRIGGERED)
        m_triggeredSpell = true;
 
    m_requiresCP = getSpellInfo()->getAttributesEx() & (ATTRIBUTESEX_REQ_COMBO_POINTS1 | ATTRIBUTESEX_REQ_COMBO_POINTS2);
 
    m_uniqueHittedTargets.clear();
    m_missedTargets.clear();
 
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        isEffectDamageStatic[i] = false;
        effectPctModifier[i] = 1.0f;
 
        m_effectTargets[i].clear();
    }
 
    // Check if spell is reflectable
    if (getSpellInfo()->getDmgClass() == SPELL_DMG_TYPE_MAGIC && !getSpellInfo()->isPassive() &&
        !(getSpellInfo()->getAttributes() & ATTRIBUTES_ABILITY) && !(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_CANT_BE_REFLECTED) &&
        !(getSpellInfo()->getAttributes() & ATTRIBUTES_IGNORE_INVULNERABILITY))
    {
        //\ todo: this is not correct but it works for now
        //\ need to check for effect rather than target type
        for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            switch (getSpellInfo()->getEffectImplicitTargetA(i))
            {
                case EFF_TARGET_SINGLE_ENEMY:
                case EFF_TARGET_ALL_ENEMIES_AROUND_CASTER:
                case EFF_TARGET_IN_FRONT_OF_CASTER:
                case EFF_TARGET_DUEL:
                    m_canBeReflected = true;
                    break;
                default:
                    break;
            }
 
            if (m_canBeReflected)
                break;
        }
    }
 
    forced_basepoints = std::make_shared<SpellForcedBasePoints>();
}

Here is the call graph for this function:

◆ ~Spell()

Spell::~Spell ( )

Definition at line 215 of file Spell.cpp.

{
#if VERSION_STRING >= WotLK
    // If this spell deals with rune power, send spell_go to update client
    // For instance, when Dk cast Empower Rune Weapon, if we don't send spell_go, the client won't update
    if (getSpellInfo()->getFirstSchoolFromSchoolMask() && getSpellInfo()->getPowerType() == POWER_TYPE_RUNES)
        sendSpellGo();
#endif
 
    m_caster->m_pendingSpells.erase(this);
 
    ///////////////////////////// This is from the virtual_destructor shit ///////////////
    for (uint8_t i = 0; i < CURRENT_SPELL_MAX; ++i)
    {
        if (m_caster->getCurrentSpell(CurrentSpellType(i)) == this)
            m_caster->interruptSpellWithSpellType(CurrentSpellType(i));
    }
 
    if (m_spellInfo_override)
        delete[] m_spellInfo_override;
    ////////////////////////////////////////////////////////////////////////////////////////
 
 
    for (auto& effectTarget : m_effectTargets)
        effectTarget.clear();
 
    m_uniqueHittedTargets.clear();
    m_missedTargets.clear();
 
    m_hitEffects.clear();
    m_missEffects.clear();
    m_critTargets.clear();
 
    m_usedModifiers.clear();
    m_pendingAuras.clear();
}

Here is the call graph for this function:

Member Function Documentation

◆ _getSpellTravelTimeForTarget()

float_t Spell::_getSpellTravelTimeForTarget ( uint64_t guid ) const

private

Definition at line 6267 of file Spell.cpp.

{
    // Handle instant spells instantly
    if (getSpellInfo()->getSpeed() == 0)
        return 0.0f;
 
    float_t destX = 0.0f, destY = 0.0f, destZ = 0.0f, distance = 0.0f;
 
    // Use destination only if the spell has no unit target mask set
    if (m_targets.hasDestination() && !(m_targets.getTargetMask() & TARGET_FLAG_UNIT))
    {
        const auto dest = m_targets.getDestination();
        destX = dest.x;
        destY = dest.y;
        destZ = dest.z;
 
        distance = m_caster->CalcDistance(destX, destY, destZ);
    }
    else if (guid == 0)
    {
        return -1.0f;
    }
    else
    {
        if (!m_caster->IsInWorld())
            return -1.0f;
 
        if (m_caster->getGuid() != guid)
        {
            const auto obj = m_caster->getWorldMapObject(guid);
            if (obj == nullptr)
                return -1.0f;
 
            destX = obj->GetPositionX();
            destY = obj->GetPositionY();
            //\todo this should be destz = obj->GetPositionZ() + (obj->GetModelHighBoundZ() / 2 * obj->getScale())
            if (obj->isCreatureOrPlayer())
                destZ = obj->GetPositionZ() + static_cast<Unit*>(obj)->getModelHalfSize();
            else
                destZ = obj->GetPositionZ();
 
            distance = m_caster->CalcDistance(destX, destY, destZ);
        }
    }
 
    if (distance == 0.0f)
        return 0.0f;
 
    if (m_missileTravelTime != 0)
        return static_cast<float_t>(m_missileTravelTime);
 
    // Calculate time it takes for spell to hit target
    return distance * 1000.0f / getSpellInfo()->getSpeed();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _loadInitialTargetPointers()

void Spell::_loadInitialTargetPointers ( bool reset = false )

private

Definition at line 6234 of file Spell.cpp.

{
    unsetAllTargets();
 
    if (reset)
        return;
 
    if (m_targets.getGameObjectTargetGuid() != 0)
        m_gameObjTarget = m_caster->getWorldMapGameObject(m_targets.getGameObjectTargetGuid());
 
    if (m_targets.getItemTargetGuid() != 0 && getPlayerCaster() != nullptr)
    {
        if (m_targets.isTradeItem())
        {
            const auto* const playerTrader = getPlayerCaster()->getTradeTarget();
            if (playerTrader != nullptr)
                m_itemTarget = playerTrader->getTradeData()->getTradeItem(TradeSlots(m_targets.getItemTargetGuid()));
        }
        else
        {
            m_itemTarget = getPlayerCaster()->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
        }
    }
 
    if (m_targets.getUnitTargetGuid() != 0)
    {
        m_unitTarget = m_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
 
        if (m_unitTarget != nullptr && m_unitTarget->isPlayer())
            m_playerTarget = dynamic_cast<Player*>(m_unitTarget);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _prepareProcFlags()

void Spell::_prepareProcFlags ( )

private

Definition at line 6322 of file Spell.cpp.

{
    // Setup spell target mask
    uint32_t spellTargetMask = 0;
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (getSpellInfo()->getEffect(i) == 0)
            continue;
 
        // Skip targets on following effects
        // Procs for these effects are handled when the real spell is casted
        if (getSpellInfo()->getEffect(i) == SPELL_EFFECT_DUMMY ||
            getSpellInfo()->getEffect(i) == SPELL_EFFECT_SCRIPT_EFFECT ||
            getSpellInfo()->getEffect(i) == SPELL_EFFECT_TRIGGER_SPELL
#if VERSION_STRING >= TBC
            || getSpellInfo()->getEffect(i) == SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE
#endif
            )
            continue;
 
        spellTargetMask |= getSpellInfo()->getRequiredTargetMaskForEffect(i);
    }
 
    if (spellTargetMask == 0)
        return;
 
    // Set initial proc flags here, correct flags are set in Object::doSpellDamage and ::doSpellHealing
    // Consider the spell negative if it requires an attackable target
    const auto spellDamageType = getSpellInfo()->getDmgClass();
    if (spellTargetMask & SPELL_TARGET_REQUIRE_ATTACKABLE)
    {
        if (spellDamageType == SPELL_DMG_TYPE_NONE)
        {
            m_casterProcFlags = PROC_ON_DONE_NEGATIVE_SPELL_DAMAGE_CLASS_NONE;
            m_targetProcFlags = PROC_ON_TAKEN_NEGATIVE_SPELL_DAMAGE_CLASS_NONE;
        }
        else if (spellDamageType == SPELL_DMG_TYPE_MAGIC)
        {
            m_casterProcFlags = PROC_ON_DONE_NEGATIVE_SPELL_DAMAGE_CLASS_MAGIC;
            m_targetProcFlags = PROC_ON_TAKEN_NEGATIVE_SPELL_DAMAGE_CLASS_MAGIC;
        }
    }
    else
    {
        if (spellDamageType == SPELL_DMG_TYPE_NONE)
        {
            m_casterProcFlags = PROC_ON_DONE_POSITIVE_SPELL_DAMAGE_CLASS_NONE;
            m_targetProcFlags = PROC_ON_TAKEN_POSITIVE_SPELL_DAMAGE_CLASS_NONE;
        }
        else if (spellDamageType == SPELL_DMG_TYPE_MAGIC)
        {
            m_casterProcFlags = PROC_ON_DONE_POSITIVE_SPELL_DAMAGE_CLASS_MAGIC;
            m_targetProcFlags = PROC_ON_TAKEN_POSITIVE_SPELL_DAMAGE_CLASS_MAGIC;
        }
    }
 
    auto isCasterOnlyTarget = false;
    if (m_uniqueHittedTargets.size() == 1)
        isCasterOnlyTarget = m_caster->getGuid() == m_uniqueHittedTargets.front().first;
 
    // These proc flags should not be applied if spell has no targets or is only targeting caster
    if (!(spellTargetMask & SPELL_TARGET_OBJECT_SELF) && m_uniqueHittedTargets.size() > 0 && !isCasterOnlyTarget)
    {
        // Set initial flags here, correct flags are set in Unit::Strike
        if (spellDamageType == SPELL_DMG_TYPE_MELEE)
        {
            m_casterProcFlags = PROC_ON_DONE_MELEE_SPELL_HIT;
            m_targetProcFlags = PROC_ON_TAKEN_MELEE_SPELL_HIT;
        }
        else if (spellDamageType == SPELL_DMG_TYPE_RANGED)
        {
            m_casterProcFlags = PROC_ON_DONE_RANGED_SPELL_HIT;
            m_targetProcFlags = PROC_ON_TAKEN_RANGED_SPELL_HIT;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _updateCasterPointers()

void Spell::_updateCasterPointers ( Object * caster )

private

Definition at line 6129 of file Spell.cpp.

{
    p_caster = nullptr;
    u_caster = nullptr;
    i_caster = nullptr;
    g_caster = nullptr;
 
    m_caster = caster;
    switch (caster->getObjectTypeId())
    {
        case TYPEID_PLAYER:
            p_caster = dynamic_cast<Player*>(caster);
        [[fallthrough]];
        case TYPEID_UNIT:
            u_caster = dynamic_cast<Unit*>(caster);
            break;
        case TYPEID_ITEM:
        case TYPEID_CONTAINER:
            i_caster = dynamic_cast<Item*>(caster);
            break;
        case TYPEID_GAMEOBJECT:
            g_caster = dynamic_cast<GameObject*>(caster);
            break;
        default:
            sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::_updateCasterPointers : Incompatible object type (type {}) for spell caster", caster->getObjectTypeId());
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _updateTargetPointers()

void Spell::_updateTargetPointers ( const uint64_t targetGuid )

private

Definition at line 6158 of file Spell.cpp.

{
    unsetAllTargets();
 
    if (targetGuid == 0)
    {
        if (getPlayerCaster() != nullptr)
        {
            if (m_targets.getTargetMask() & TARGET_FLAG_ITEM)
                m_itemTarget = getPlayerCaster()->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
 
            if (m_targets.isTradeItem())
            {
                const auto trader = getPlayerCaster()->getTradeTarget();
                if (trader != nullptr)
                    m_itemTarget = trader->getTradeData()->getTradeItem(TradeSlots(m_targets.getItemTargetGuid()));
            }
        }
    }
    else if (targetGuid == getCaster()->getGuid())
    {
        m_unitTarget = getUnitCaster();
        m_itemTarget = getItemCaster();
        m_gameObjTarget = getGameObjectCaster();
        m_playerTarget = getPlayerCaster();
    }
    else
    {
        if (!getCaster()->IsInWorld())
            return;
 
        if (m_targets.isTradeItem())
        {
            if (getPlayerCaster() != nullptr)
            {
                const auto trader = getPlayerCaster()->getTradeTarget();
                if (trader != nullptr)
                    m_itemTarget = trader->getTradeData()->getTradeItem(TradeSlots(targetGuid));
            }
        }
        else
        {
            WoWGuid wowGuid;
            wowGuid.Init(targetGuid);
 
            switch (wowGuid.getHigh())
            {
                case HighGuid::Unit:
                case HighGuid::Vehicle:
                    m_unitTarget = getCaster()->getWorldMap()->getCreature(wowGuid.getGuidLowPart());
                    break;
                case HighGuid::Pet:
                    m_unitTarget = getCaster()->getWorldMap()->getPet(wowGuid.getGuidLowPart());
                    break;
                case HighGuid::Player:
                    m_unitTarget = getCaster()->getWorldMap()->getPlayer(wowGuid.getGuidLowPart());
                    m_playerTarget = dynamic_cast<Player*>(m_unitTarget);
                    break;
                case HighGuid::Item:
                    if (getPlayerCaster() != nullptr)
                        m_itemTarget = getPlayerCaster()->getItemInterface()->GetItemByGUID(targetGuid);
                    break;
                case HighGuid::GameObject:
                    m_gameObjTarget = getCaster()->getWorldMap()->getGameObject(wowGuid.getGuidLowPart());
                    break;
                case HighGuid::Corpse:
                    m_corpseTarget = sObjectMgr.getCorpseByGuid(wowGuid.getGuidLowPart());
                    break;
                default:
                    sLogger.failure("Spell::_updateTargetPointers : Invalid object type for spell target (low guid {}) in spell {}", wowGuid.getGuidLowPart(), getSpellInfo()->getId());
                    break;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddAOETargets()

void Spell::AddAOETargets	(	uint32_t	i,
		uint32_t	TargetType,
		float	r,
		uint32_t	maxtargets
	)

Definition at line 305 of file SpellTarget.Legacy.cpp.

{
    LocationVector source;
 
    //cant do raid/party stuff here, seperate functions for it
    if (targetType & (SPELL_TARGET_AREA_PARTY | SPELL_TARGET_AREA_RAID) && !(p_caster == nullptr && !m_caster->isPet() && (!m_caster->isCreature() || !m_caster->isTotem())))
        return;
 
    Object* tarobj = m_caster->getWorldMap()->getObject(m_targets.getUnitTargetGuid());
 
    if (targetType & SPELL_TARGET_AREA_SELF)
        source = m_caster->GetPosition();
    else if (targetType & SPELL_TARGET_AREA_CURTARGET && tarobj != nullptr)
        source = tarobj->GetPosition();
    else
    {
        if (!m_targets.getDestination().isSet())
        {
            // If position is not set, try unit target's position
            if (m_targets.getUnitTargetGuid() != 0)
            {
                const auto targetUnit = m_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
                if (targetUnit != nullptr)
                    m_targets.setDestination(targetUnit->GetPosition());
            }
 
            // Check again if position was set
            if (!m_targets.getDestination().isSet())
            {
                // No unit target => use caster's position
                m_targets.setDestination(m_caster->GetPosition());
            }
        }
 
        source = m_targets.getDestination();
    }
 
    //caster might be in the aoe LOL
    if (!(targetType & SPELL_TARGET_REQUIRE_ATTACKABLE))
    {
        if (m_caster->CalcDistance(source) <= r)
            AddTarget(i, targetType, m_caster);
    }
 
    std::vector<uint64_t>* t = &m_effectTargets[i];
 
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        if (!itr)
            continue;
 
        if (maxtargets != 0 && t->size() >= maxtargets)
            break;
 
        float dist = itr->CalcDistance(source);
        if (dist <= r)
            AddTarget(i, targetType, itr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddChainTargets()

void Spell::AddChainTargets	(	uint32_t	i,
		uint32_t	TargetType,
		float	r,
		uint32_t	maxtargets
	)

Definition at line 161 of file SpellTarget.Legacy.cpp.

{
    if (!m_caster->IsInWorld())
        return;
 
    Object* targ = m_caster->getWorldMap()->getObject(m_targets.getUnitTargetGuid());
 
    if (targ == nullptr)
        return;
 
    std::vector<uint64_t>* list = &m_effectTargets[i];
 
    //if selected target is party member, then jumps on party
    Unit* firstTarget = nullptr;
 
    if (targ->isCreatureOrPlayer())
        firstTarget = static_cast<Unit*>(targ);
    else
        firstTarget = u_caster;
 
    bool RaidOnly = false;
    float range = m_spellInfo->getMaxRange(false, m_caster, this);//this is probably wrong,
    //this is cast distance, not searching distance
    range *= range;
 
    //is this party only?
    Player* casterFrom = u_caster->getPlayerOwnerOrSelf();
    Player* pfirstTargetFrom = firstTarget->getPlayerOwnerOrSelf();
    if (casterFrom != nullptr && pfirstTargetFrom != nullptr && casterFrom->getGroup() == pfirstTargetFrom->getGroup())
        RaidOnly = true;
 
    uint32_t jumps = m_spellInfo->getEffectChainTarget(static_cast<uint8_t>(i));
 
    //range
    range /= jumps; //hacky, needs better implementation!
 
    u_caster->applySpellModifiers(SPELLMOD_ADDITIONAL_TARGET, &jumps, getSpellInfo(), this);
 
    AddTarget(i, targetType, firstTarget);
 
    if (jumps <= 1 || list->size() == 0) //1 because we've added the first target, 0 size if spell is resisted
        return;
 
    for (const auto& itr : firstTarget->getInRangeObjectsSet())
    {
        auto obj = itr;
        if (!obj || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
 
        if (RaidOnly && !pfirstTargetFrom->isUnitOwnerInRaid(static_cast<Unit*>(itr)))
            continue;
 
        //healing spell, full health target = NONO
        if (m_spellInfo->isHealingSpell() && static_cast<Unit*>(itr)->getHealthPct() == 100)
            continue;
 
        if (obj->isInRange(firstTarget->GetPositionX(), firstTarget->GetPositionY(), firstTarget->GetPositionZ(), range))
        {
            size_t oldsize = list->size();
            AddTarget(i, targetType, itr);
            if (list->size() == oldsize || list->size() >= jumps) //either out of jumps or a resist
                return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddConeTargets()

void Spell::AddConeTargets	(	uint32_t	i,
		uint32_t	TargetType,
		float	r,
		uint32_t	maxtargets
	)

Definition at line 140 of file SpellTarget.Legacy.cpp.

{
    std::vector<uint64_t>* list = &m_effectTargets[i];
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        if (!itr || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
 
        //is Creature in range
        if (m_caster->isInRange(itr, getEffectRadius(i)))
        {
            if (m_spellInfo->cone_width ? m_caster->isInArc(itr, m_spellInfo->cone_width) : m_caster->isInFront(itr))  // !!! is the target within our cone ?
            {
                AddTarget(i, targetType, itr);
            }
        }
        if (maxtargets != 0 && list->size() >= maxtargets)
            return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddPartyTargets()

void Spell::AddPartyTargets	(	uint32_t	i,
		uint32_t	TargetType,
		float	r,
		uint32_t	maxtargets
	)

Definition at line 227 of file SpellTarget.Legacy.cpp.

{
    Object* u = m_caster->getWorldMap()->getObject(m_targets.getUnitTargetGuid());
    if (u == nullptr)
        u = m_caster;
 
    // If spell has area aura effect, aura code will handle proper targetting
    // so add just caster
    if (getSpellInfo()->isAreaAuraEffect(i))
    {
        AddTarget(i, targetType, u);
        return;
    }
 
    Player* p = u->getPlayerOwnerOrSelf();
    if (p == nullptr || u_caster == nullptr)
        return;
 
    AddTarget(i, targetType, p);
 
    for (const auto& itr : u->getInRangeObjectsSet())
    {
        if (!itr || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
 
        //only affect players and pets
        if (!itr->isPlayer() && !itr->isPet())
            continue;
 
        if (!p->isUnitOwnerInParty(static_cast<Unit*>(itr)))
            continue;
 
        if (u->CalcDistance(itr) > r)
            continue;
 
        AddTarget(i, targetType, itr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddRaidTargets()

void Spell::AddRaidTargets	(	uint32_t	i,
		uint32_t	TargetType,
		float	r,
		uint32_t	maxtargets,
		bool	partylimit = `false`
	)

Definition at line 266 of file SpellTarget.Legacy.cpp.

{
    Object* u = m_caster->getWorldMap()->getObject(m_targets.getUnitTargetGuid());
    if (u == nullptr)
        u = m_caster;
 
    // If spell has area aura effect, aura code will handle proper targetting
    // so add just caster
    if (getSpellInfo()->isAreaAuraEffect(i))
    {
        AddTarget(i, targetType, u);
        return;
    }
 
    Player* p = u->getPlayerOwnerOrSelf();
    if (p == nullptr || u_caster == nullptr)
        return;
 
    AddTarget(i, targetType, p);
 
    for (const auto& itr : u->getInRangeObjectsSet())
    {
        if (!itr || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
 
        //only affect players and pets
        if (!itr->isPlayer() && !itr->isPet())
            continue;
 
        if (!p->isUnitOwnerInRaid(static_cast<Unit*>(itr)))
            continue;
 
        if (u->CalcDistance(itr) > r)
            continue;
 
        AddTarget(i, targetType, itr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddScriptedOrSpellFocusTargets()

void Spell::AddScriptedOrSpellFocusTargets	(	uint32_t	i,
		uint32_t	TargetType,
		float	r,
		uint32_t	maxtargets
	)

Definition at line 118 of file SpellTarget.Legacy.cpp.

{
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        Object* o = itr;
        if (!o || !o->isGameObject())
            continue;
 
        GameObject* go = static_cast<GameObject*>(o);
        if (go->GetGameObjectProperties()->raw.parameter_0 == m_spellInfo->getRequiresSpellFocus())
        {
            if (!m_caster->isInRange(go, r))
                continue;
 
            bool success = AddTarget(i, targetType, go);
 
            if (success)
                return;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddTarget()

bool Spell::AddTarget	(	uint32_t	i,
		uint32_t	TargetType,
		Object *	obj
	)

Todo:: Add support for this in arcemu

Definition at line 365 of file SpellTarget.Legacy.cpp.

{
    const auto targetCheck = checkExplicitTarget(obj, TargetType);
    if (targetCheck != SPELL_CAST_SUCCESS)
        return false;
 
    // If checked in checkExplicitTarget, initial aoe spell cast check can fail
    if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_TARGET_ONLY_PLAYERS && !obj->isPlayer())
        return false;
 
    if (u_caster != nullptr && u_caster->hasUnitFlags(UNIT_FLAG_IGNORE_PLAYER_COMBAT) && ((obj->isPlayer() || obj->isPet()) || (p_caster != nullptr || m_caster->isPet())))
        return false;
 
    std::vector<uint64_t>* t = &m_effectTargets[i];
 
    SpellDidHitResult hitresult = (TargetType & SPELL_TARGET_REQUIRE_ATTACKABLE && obj->isCreatureOrPlayer()) ? static_cast<SpellDidHitResult>(DidHit(i, static_cast<Unit*>(obj))) : SPELL_DID_HIT_SUCCESS;
    if (hitresult != SPELL_DID_HIT_SUCCESS)
    {
        SpellDidHitResult extended = SPELL_DID_HIT_SUCCESS;
        if (hitresult == SPELL_DID_HIT_REFLECT && u_caster != nullptr)
        {
            //for checks
            Unit* tmp = u_caster;
            u_caster = static_cast<Unit*>(obj);
            extended = static_cast<SpellDidHitResult>(DidHit(i, tmp));
            u_caster = tmp;
        }
        safeAddMissedTarget(obj->getGuid(), hitresult, extended);
        return false;
    }
    else
    {
        //check target isnt already in
        for (std::vector<uint64_t>::iterator itr = m_effectTargets[i].begin(); itr != m_effectTargets[i].end(); ++itr)
        {
            if (obj->getGuid() == *itr)
                return false;
        }
        t->push_back(obj->getGuid());
    }
 
    //final checks, require line of sight unless range/radius is 50000 yards
    auto spell_range = sSpellRangeStore.lookupEntry(m_spellInfo->getRangeIndex());
    if (spell_range != nullptr)
    {
        if (worldConfig.terrainCollision.isCollisionEnabled && spell_range->maxRange < 50000 && getEffectRadius(i) < 50000 && !obj->isItem())
        {
            float x = m_caster->GetPositionX(), y = m_caster->GetPositionY(), z = m_caster->GetPositionZ() + 0.5f;
 
            //are we using a different location?
            if (TargetType & SPELL_TARGET_AREA)
            {
                auto destination = m_targets.getDestination();
                x = destination.x;
                y = destination.y;
                z = destination.z;
            }
            else if (TargetType & SPELL_TARGET_AREA_CHAIN)
            {
                ///\todo Add support for this in arcemu
                /*Object* lasttarget = NULL;
                if (m_orderedObjects.size() > 0)
                {
                lasttarget = m_caster->getWorldMap()->_GetObject(m_orderedObjects[m_orderedObjects.size() - 1]);
                if (lasttarget != NULL)
                {
                x = lasttarget->GetPositionX();
                y = lasttarget->GetPositionY();
                z = lasttarget->GetPositionZ();
                }
                }*/
            }
 
            bool isInLOS = m_caster->getWorldMap()->isInLineOfSight(LocationVector(x, y, z), obj->GetPosition(), m_caster->GetPhase(), LineOfSightChecks::LINEOFSIGHT_ALL_CHECKS);
 
            if (!isInLOS)
                return false;
        }
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddTime()

void Spell::AddTime ( uint32_t type )

Definition at line 1101 of file Spell.Legacy.cpp.

{
    if (u_caster != nullptr)
    {
        if (getSpellInfo()->getInterruptFlags() & CAST_INTERRUPT_ON_DAMAGE_TAKEN)
        {
            u_caster->interruptSpell(getSpellInfo()->getId());
            return;
        }
 
        float ch = 0;
        u_caster->applySpellModifiers(SPELLMOD_NONINTERRUPT, &ch, getSpellInfo(), this);
        if (Util::checkChance(ch))
            return;
 
        if (p_caster != nullptr)
        {
            if (Util::checkChance(p_caster->m_spellDelayResist[type]))
                return;
        }
        if (m_DelayStep == 2)
            return; //spells can only be delayed twice as of 3.0.2
        if (m_spellState == SPELL_STATE_CASTING)
        {
            // no pushback for some spells
            if ((getSpellInfo()->getInterruptFlags() & CAST_INTERRUPT_PUSHBACK) == 0)
                return;
            int32_t delay = 500; //0.5 second pushback
            ++m_DelayStep;
            m_timer += delay;
            if (m_timer > m_castTime)
            {
                delay -= (m_timer - m_castTime);
                m_timer = m_castTime;
                if (delay < 0)
                    delay = 1;
            }
 
            u_caster->sendMessageToSet(SmsgSpellDelayed(u_caster->GetNewGUID(), delay).serialise().get(), true);
 
            if (p_caster == nullptr)
            {
                //then it's a Creature
                u_caster->pauseMovement(delay);
            }
            //in case cast is delayed, make sure we do not exit combat
            else
            {
                // sEventMgr.ModifyEventTimeLeft(p_caster,EVENT_ATTACK_TIMEOUT,attackTimeoutInterval,true);
                // also add a new delay to offhand and main hand attacks to avoid cutting the cast short
 
                // TODO: should spell cast time pushback reset swing timers again? -Appled
                //p_caster->delayMeleeAttackTimer(delay);
            }
        }
        else if (getSpellInfo()->getChannelInterruptFlags() != 48140)
        {
            int32_t delay = getDuration() / 4; //0.5 second push back
            ++m_DelayStep;
            m_timer -= delay;
            if (m_timer < 0)
                m_timer = 0;
            //else if (p_caster != nullptr)
                // TODO: should spell cast time pushback reset swing timers again? -Appled
                //p_caster->delayMeleeAttackTimer(-delay);
 
            m_Delayed = true;
            if (m_timer > 0)
                sendChannelUpdate(m_timer);
 
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addUsedSpellModifier()

void Spell::addUsedSpellModifier ( AuraEffectModifier const * aurEff )

Definition at line 5851 of file Spell.cpp.

{
    for (const auto& usedMod : m_usedModifiers)
    {
        if (usedMod.first == aurEff)
            return;
    }
 
    m_usedModifiers.insert(std::make_pair(aurEff, false));
}

Here is the caller graph for this function:

◆ ApplyAreaAura()

void Spell::ApplyAreaAura ( uint8_t effectIndex )

Definition at line 710 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive()) return;
    if (u_caster != m_unitTarget) return;
 
    Aura* pAura = nullptr;
    auto itr = m_pendingAuras.find(m_unitTarget->getGuid());
    if (itr == m_pendingAuras.end())
    {
        auto auraHolder = sSpellMgr.newAura(getSpellInfo(), getDuration(), m_caster, m_unitTarget);
 
        float r = getEffectRadius(effectIndex);
 
        uint32_t eventtype = 0;
 
        switch (m_spellInfo->getEffect(effectIndex))
        {
            case SPELL_EFFECT_APPLY_GROUP_AREA_AURA:
                eventtype = EVENT_GROUP_AREA_AURA_UPDATE;
                break;
            case SPELL_EFFECT_APPLY_RAID_AREA_AURA:
                eventtype = EVENT_RAID_AREA_AURA_UPDATE;
                break;
            case SPELL_EFFECT_APPLY_PET_AREA_AURA:
                eventtype = EVENT_PET_AREA_AURA_UPDATE;
                break;
            case SPELL_EFFECT_APPLY_FRIEND_AREA_AURA:
                eventtype = EVENT_FRIEND_AREA_AURA_UPDATE;
                break;
            case SPELL_EFFECT_APPLY_ENEMY_AREA_AURA:
                eventtype = EVENT_ENEMY_AREA_AURA_UPDATE;
                break;
#if VERSION_STRING >= TBC
            case SPELL_EFFECT_APPLY_OWNER_AREA_AURA:
                eventtype = EVENT_ENEMY_AREA_AURA_UPDATE; //Zyres: The same event as SPELL_EFFECT_APPLY_ENEMY_AREA_AURA? @Appled o.O
#endif
                break;
        }
 
        auraHolder->m_castedItemId = castedItemId;
 
        if (!sEventMgr.HasEvent(auraHolder.get(), eventtype))      /* only add it once */
            sEventMgr.AddEvent(auraHolder.get(), &Aura::EventUpdateAreaAura, effectIndex, r * r, eventtype, 1000, 0, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
 
        const auto [itr, _] = m_pendingAuras.try_emplace(m_unitTarget->getGuid(), 0, std::move(auraHolder));
        pAura = itr->second.aur.get();
    }
    else
    {
        pAura = itr->second.aur.get();
    }
 
    pAura->addAuraEffect(static_cast<AuraEffect>(getSpellInfo()->getEffectApplyAuraName(effectIndex)), damage, getSpellInfo()->getEffectMiscValue(effectIndex), effectPctModifier[effectIndex], isEffectDamageStatic[effectIndex], effectIndex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculateEffect()

int32_t Spell::calculateEffect ( uint8_t effIndex )

Definition at line 1469 of file Spell.cpp.

{
    auto value = getSpellInfo()->calculateEffectValue(effIndex, getUnitCaster(), getItemCaster(), *forced_basepoints);
 
    // Legacy script hook
    value = DoCalculateEffect(effIndex, getUnitTarget(), value);
 
    const auto scriptResult = sScriptMgr.callScriptedSpellDoCalculateEffect(this, effIndex, &value);
 
    // If effect damage was recalculated in script, send static damage in effect handlers
    // so for example spell power bonus won't get calculated twice
    isEffectDamageStatic[effIndex] = scriptResult != SpellScriptEffectDamage::DAMAGE_DEFAULT;
    if (scriptResult == SpellScriptEffectDamage::DAMAGE_FULL_RECALCULATION)
        return value;
 
    if (getPlayerCaster() != nullptr)
    {
        const auto itr = getPlayerCaster()->m_spellOverrideMap.find(getSpellInfo()->getId());
        if (itr != getPlayerCaster()->m_spellOverrideMap.end())
        {
            for (auto scriptOverride = itr->second->begin(); scriptOverride != itr->second->end(); ++scriptOverride)
            {
                value += Util::getRandomUInt((*scriptOverride)->damage);
            }
        }
    }
 
    if (getUnitCaster() != nullptr)
    {
        // Calculate spell and attack power bonus (must be calculated on launch, not on spell hit!)
        if (!isEffectDamageStatic[effIndex])
        {
            switch (getSpellInfo()->getEffect(effIndex))
            {
                case SPELL_EFFECT_SCHOOL_DAMAGE:
                    value = static_cast<int32_t>(std::ceil(getUnitCaster()->applySpellDamageBonus(getSpellInfo(), value, 1.0f, false, this)));
                    break;
                case SPELL_EFFECT_HEAL:
                case SPELL_EFFECT_HEAL_MECHANICAL:
                    value = static_cast<int32_t>(std::ceil(getUnitCaster()->applySpellHealingBonus(getSpellInfo(), value, 1.0f, false, this)));
                    break;
                default:
                    break;
            }
        }
 
        // Save pct modifiers before applying so they can be readded properly later
        int32_t spellFlatMods = 0, spellPctMods = 100;
 
        getUnitCaster()->getTotalSpellModifiers(SPELLMOD_ALL_EFFECTS, value, &spellFlatMods, &spellPctMods, getSpellInfo(), this, nullptr, true);
        getUnitCaster()->applySpellModifiers(SPELLMOD_ALL_EFFECTS, &value, getSpellInfo(), this);
 
        getUnitCaster()->getTotalSpellModifiers(SPELLMOD_EFFECT_BONUS, value, &spellFlatMods, &spellPctMods, getSpellInfo(), this, nullptr, true);
        getUnitCaster()->applySpellModifiers(SPELLMOD_EFFECT_BONUS, &value, getSpellInfo(), this);
 
        switch (effIndex)
        {
            case 0:
                getUnitCaster()->getTotalSpellModifiers(SPELLMOD_EFFECT_1, value, &spellFlatMods, &spellPctMods, getSpellInfo(), this, nullptr, true);
                getUnitCaster()->applySpellModifiers(SPELLMOD_EFFECT_1, &value, getSpellInfo(), this);
                break;
            case 1:
                getUnitCaster()->getTotalSpellModifiers(SPELLMOD_EFFECT_2, value, &spellFlatMods, &spellPctMods, getSpellInfo(), this, nullptr, true);
                getUnitCaster()->applySpellModifiers(SPELLMOD_EFFECT_2, &value, getSpellInfo(), this);
                break;
            case 2:
                getUnitCaster()->getTotalSpellModifiers(SPELLMOD_EFFECT_3, value, &spellFlatMods, &spellPctMods, getSpellInfo(), this, nullptr, true);
                getUnitCaster()->applySpellModifiers(SPELLMOD_EFFECT_3, &value, getSpellInfo(), this);
                break;
            default:
                break;
        }
 
        effectPctModifier[effIndex] = spellPctMods / 100.0f;
    }
    else if (getItemCaster() != nullptr && getUnitTarget() != nullptr)
    {
        // Apply spell modifiers from the item owner
        const auto itemCreator = getUnitTarget()->getWorldMapUnit(getItemCaster()->getCreatorGuid());
        if (itemCreator != nullptr)
        {
            itemCreator->applySpellModifiers(SPELLMOD_ALL_EFFECTS, &value, getSpellInfo(), this);
            itemCreator->applySpellModifiers(SPELLMOD_EFFECT_BONUS, &value, getSpellInfo(), this);
        }
    }
 
    return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculateJumpSpeeds()

void Spell::calculateJumpSpeeds	(	Unit *	unitCaster,
		SpellInfo const *	spellInfo,
		uint8_t	i,
		float	dist,
		float &	speedXY,
		float &	speedZ
	)

Definition at line 3000 of file Spell.Legacy.cpp.

{
    float runSpeed = unitCaster->getSpeedRate(TYPE_RUN, false);
 
    if (Creature* creature = unitCaster->ToCreature())
        runSpeed *= creature->GetCreatureProperties()->run_speed;
 
    float multiplier = m_spellInfo->getEffectMultipleValue(i);
    if (multiplier <= 0.0f)
        multiplier = 1.0f;
 
    speedXY = std::min(runSpeed * 3.0f * multiplier, std::max(28.0f, unitCaster->getSpeedRate(TYPE_RUN, false) * 4.0f));
 
    float duration = dist / speedXY;
    float durationSqr = duration * duration;
    float minHeight = spellInfo->getEffectMiscValue(i) ? spellInfo->getEffectMiscValue(i) / 10.0f : 0.5f; // Lower bound is blizzlike
    float maxHeight = spellInfo->getEffectMiscValueB(i) ? spellInfo->getEffectMiscValueB(i) / 10.0f : 1000.0f; // Upper bound is unknown
    float height;
 
    if (durationSqr < minHeight * 8 / MovementMgr::gravity)
        height = minHeight;
    else if (durationSqr > maxHeight * 8 / MovementMgr::gravity)
        height = maxHeight;
    else
        height = MovementMgr::gravity * durationSqr / 8;
 
    speedZ = std::sqrt(2 * MovementMgr::gravity * height);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ calculatePowerCost()

uint32_t Spell::calculatePowerCost ( )

private

Definition at line 5595 of file Spell.cpp.

{
    // Null for non-unit casters
    if (u_caster == nullptr)
        return 0;
 
    auto powerCost = getSpellInfo()->getBasePowerCost(u_caster);
 
    // Use first school found from mask
    const auto spellSchool = getSpellInfo()->getFirstSchoolFromSchoolMask();
 
    // Include power cost modifiers from that school
    powerCost += u_caster->getPowerCostModifier(spellSchool);
 
    // Special case for rogue's Shiv - power cost depends on the speed of offhand weapon
    if (getSpellInfo()->getAttributesExD() & ATTRIBUTESEXD_SHIV)
    {
        // Formula seems to be 20 + offhand weapon speed in seconds * 10
        powerCost += u_caster->getBaseAttackTime(OFFHAND) / 100;
    }
 
    // Apply modifiers
    u_caster->applySpellModifiers(SPELLMOD_COST, &powerCost, getSpellInfo(), this);
 
    // Include power cost multipliers from that school
    powerCost = static_cast<int32_t>(powerCost * (1.0f + u_caster->getPowerCostMultiplier(spellSchool)));
 
    if (powerCost < 0)
        powerCost = 0;
 
    return static_cast<uint32_t>(powerCost);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ canAttackCreatureType()

bool Spell::canAttackCreatureType ( Creature * target ) const

private

Definition at line 6002 of file Spell.cpp.

{
    // Skip check for Grounding Totem
    if (target->getCreatedBySpellId() == 8177)
        return true;
 
    const auto typeMask = getSpellInfo()->getTargetCreatureType();
    const auto mask = 1 << (target->GetCreatureProperties()->Type - 1);
    return !(target->GetCreatureProperties()->Type != 0 && typeMask != 0 && (typeMask & mask) == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanCast()

uint8_t Spell::CanCast ( bool )

Object cast checks

Check for valid targets

Check for valid location

Player caster checks

On taxi check

Is mounted check

check if spell is allowed while we have a battleground flag

Targeted Unit Checks

Definition at line 1702 of file Spell.Legacy.cpp.

{
    /**
     * Object cast checks
     */
    if (m_caster && m_caster->IsInWorld())
    {
        Unit* target = m_caster->getWorldMap()->getUnit(m_targets.getUnitTargetGuid());
 
        /**
         * Check for valid targets
         */
        if (target)
        {
            switch (getSpellInfo()->getId())
            {
                // SPELL_HASH_DEATH_PACT
                case 17471:
                case 17698:
                case 48743:
                case 51956:
                {
                    if (target->getSummonedByGuid() != m_caster->getGuid())
                        return SPELL_FAILED_BAD_TARGETS;
                } break;
            }
        }
 
        /**
         * Check for valid location
         */
        if (getSpellInfo()->getId() == 32146)
        {
            Creature* corpse = m_caster->getWorldMap()->getInterface()->getCreatureNearestCoords(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), 18240);
            if (corpse != nullptr)
                if (m_caster->CalcDistance(m_caster, corpse) > 5)
                    return SPELL_FAILED_NOT_HERE;
        }
        else if (getSpellInfo()->getId() == 39246)
        {
            Creature* cleft = m_caster->getWorldMap()->getInterface()->getCreatureNearestCoords(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), 22105);
            if (cleft == nullptr || cleft->isAlive())
                return SPELL_FAILED_NOT_HERE;
        }
        else if (getSpellInfo()->getId() == 30988)
        {
            Creature* corpse = m_caster->getWorldMap()->getInterface()->getCreatureNearestCoords(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), 17701);
            if (corpse != nullptr)
                if (m_caster->CalcDistance(m_caster, corpse) > 5 || corpse->isAlive())
                    return SPELL_FAILED_NOT_HERE;
        }
        else if (getSpellInfo()->getId() == 43723)
        {
            Creature* abysal = p_caster->getWorldMap()->getInterface()->getCreatureNearestCoords(p_caster->GetPositionX(), p_caster->GetPositionY(), p_caster->GetPositionZ(), 19973);
            if (abysal != nullptr)
            {
                if (!abysal->isAlive())
                    if (!(p_caster->getItemInterface()->GetItemCount(31672) > 1 && p_caster->getItemInterface()->GetItemCount(31673) > 0 && p_caster->CalcDistance(p_caster, abysal) < 10))
                        return SPELL_FAILED_NOT_HERE;
            }
            else
                return SPELL_FAILED_NOT_HERE;
        }
        else if (getSpellInfo()->getId() == 32307)
        {
            Creature* kilsorrow = p_caster->getWorldMap()->getInterface()->getCreatureNearestCoords(p_caster->GetPositionX(), p_caster->GetPositionY(), p_caster->GetPositionZ());
            if (kilsorrow == nullptr || kilsorrow->isAlive() || p_caster->CalcDistance(p_caster, kilsorrow) > 1)
                return SPELL_FAILED_NOT_HERE;
            if (kilsorrow->getEntry() != 17147 && kilsorrow->getEntry() != 17148 && kilsorrow->getEntry() != 18397 && kilsorrow->getEntry() != 18658 && kilsorrow->getEntry() != 17146)
                return SPELL_FAILED_NOT_HERE;
        }
    }
 
    /**
     * Player caster checks
     */
    if (p_caster)
    {
        /**
         * On taxi check
         */
        if (!p_caster->isOnTaxi())
        {
            if (getSpellInfo()->getId() == 33836 || getSpellInfo()->getId() == 45072 || getSpellInfo()->getId() == 45115 || getSpellInfo()->getId() == 31958)
                return SPELL_FAILED_NOT_HERE;
        }
 
        /**
         * Is mounted check
         */
        if (!p_caster->isMounted())
        {
            if (getSpellInfo()->getId() == 25860) // Reindeer Transformation
                return SPELL_FAILED_ONLY_MOUNTED;
        }
 
         /**
          * check if spell is allowed while we have a battleground flag
          */
        if (p_caster->hasBgFlag())
        {
            switch (getSpellInfo()->getId())
            {
                // stealth spells
                case 1784:
                case 1785:
                case 1786:
                case 1787:
                case 5215:
                case 6783:
                case 9913:
                case 1856:
                case 1857:
                case 26889:
                {
                    if (const auto battleground = p_caster->getBattleground())
                    {
                        if (battleground->getType() == BattlegroundDef::TYPE_WARSONG_GULCH)
                            battleground->HookOnFlagDrop(p_caster);
                        else if (battleground->getType() == BattlegroundDef::TYPE_EYE_OF_THE_STORM)
                            battleground->HookOnFlagDrop(p_caster);
                    }
                    break;
                }
            }
        }
    }
 
    /**
     * Targeted Unit Checks
     */
    if (m_targets.getUnitTargetGuid())
    {
        Unit* target = (m_caster->IsInWorld()) ? m_caster->getWorldMap()->getUnit(m_targets.getUnitTargetGuid()) : NULL;
 
        if (target)
        {
            // \todo Replace this awful hacks with a better solution
            // Nestlewood Owlkin - Quest 9303
            if (getSpellInfo()->getId() == 29528 && target->isCreature() && target->getEntry() == 16518)
            {
                if (target->isRooted())
                {
                    return SPELL_FAILED_BAD_TARGETS;
                }
 
                target->setTargetGuid(p_caster->getGuid());
                return SPELL_CAST_SUCCESS;
            }
 
            // Lazy Peons - Quest 5441
            if (getSpellInfo()->getId() == 19938 && target->isCreature() && target->getEntry() == 10556)
            {
                if (!target->hasAurasWithId(17743))
                {
                    return SPELL_FAILED_BAD_TARGETS;
                }
 
                return SPELL_CAST_SUCCESS;
            }
 
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
            // scripted spell stuff
            switch (getSpellInfo()->getId())
            {
                case 603: //curse of doom, can't be cast on players
                case 30910:
                case 47867: // Curse of doom rank 4
                {
                    if (target->isPlayer())
                        return SPELL_FAILED_TARGET_IS_PLAYER;
                }
                break;
                case 13907: // Smite Demon
                {
                    if (target->isPlayer() || target->getClass() != TARGET_TYPE_DEMON)
                        return SPELL_FAILED_SPELL_UNAVAILABLE;
                }
                break;
 
                default:
                    break;
            }
 
            // if the target is not the unit caster and not the masters pet
            if (target != u_caster && !m_caster->isPet())
            {
 
                /***********************************************************
                * Inface checks, these are checked in 2 ways
                * 1e way is check for damage type, as 3 is always ranged
                * 2e way is trough the data in the extraspell db
                *
                **********************************************************/
 
                uint32_t facing_flags = getSpellInfo()->getFacingCasterFlags();
 
                // Holy shock need enemies be in front of caster
                switch (getSpellInfo()->getId())
                {
                    //SPELL_HASH_HOLY_SHOCK
                    case 20473:
                    case 20929:
                    case 20930:
                    case 25902:
                    case 25903:
                    case 25911:
                    case 25912:
                    case 25913:
                    case 25914:
                    case 27174:
                    case 27175:
                    case 27176:
                    case 32771:
                    case 33072:
                    case 33073:
                    case 33074:
                    case 35160:
                    case 36340:
                    case 38921:
                    case 48820:
                    case 48821:
                    case 48822:
                    case 48823:
                    case 48824:
                    case 48825:
                    case 66114:
                    case 68014:
                    case 68015:
                    case 68016:
                    {
                        if (getSpellInfo()->getEffect(0) == SPELL_EFFECT_DUMMY && !u_caster->isFriendlyTo(target))
                            facing_flags = SPELL_INFRONT_STATUS_REQUIRE_INFRONT;
                    } break;
                }
            }
 
            // fishing spells
            if (getSpellInfo()->getEffectImplicitTargetA(0) == EFF_TARGET_SELF_FISHING)  //||
                //GetProto()->EffectImplicitTargetA[1] == EFF_TARGET_SELF_FISHING ||
                //GetProto()->EffectImplicitTargetA[2] == EFF_TARGET_SELF_FISHING)
            {
                uint32_t entry = getSpellInfo()->getEffectMiscValue(0);
                if (entry == GO_FISHING_BOBBER)
                {
                    WorldMap* map = m_caster->getWorldMap();
                    float minDist = m_spellInfo->getMinRange(true);
                    float maxDist = m_spellInfo->getMaxRange(true);
                    float posx = 0, posy = 0, posz = 0;
                    float dist = Util::getRandomFloat(minDist, maxDist);
 
                    float angle = Util::getRandomFloat(0.0f, 1.0f) * static_cast<float>(M_PI * 35.0f / 180.0f) - static_cast<float>(M_PI * 17.5f / 180.0f);
                    m_caster->getClosePoint(posx, posy, posz, 0.388999998569489f, dist, angle);
 
                    float ground = m_caster->getMapHeight(LocationVector(posx, posy, posz));
                    float liquidLevel = VMAP_INVALID_HEIGHT_VALUE;
 
                    LiquidData liquidData;
                    if (map->getLiquidStatus(m_caster->GetPhase(), LocationVector(posx, posy, posz), MAP_ALL_LIQUIDS, &liquidData, m_caster->getCollisionHeight()))
                        liquidLevel = liquidData.level;
 
                    if (liquidLevel <= ground)
                        return SPELL_FAILED_NOT_FISHABLE;
 
                    if (ground + 0.75 > liquidLevel)
#if VERSION_STRING > Classic
                        return SPELL_FAILED_TOO_SHALLOW;
#else
                        return SPELL_FAILED_NOT_FISHABLE;
#endif
 
                    // if we are already fishing, don't cast it again
                    if (p_caster->getSummonedObject())
                        if (p_caster->getSummonedObject()->getEntry() == GO_FISHING_BOBBER)
                            return SPELL_FAILED_SPELL_IN_PROGRESS;
 
                    m_targets.setDestination(LocationVector(posx, posy, liquidLevel));
                }
            }
 
            //check if we are trying to stealth or turn invisible but it is not allowed right now
            if (IsStealthSpell() || IsInvisibilitySpell())
            {
                uint32_t faerieFireFeral[] =
                {
                    //SPELL_HASH_FAERIE_FIRE__FERAL_
                    16857,
                    60089,
                    0
                };
 
                //if we have Faerie Fire, we cannot stealth or turn invisible
                uint32_t faerieFire[] =
                {
                    //SPELL_HASH_FAERIE_FIRE
                    770,
                    6950,
                    13424,
                    13752,
                    16498,
                    20656,
                    21670,
                    25602,
                    32129,
                    65863,
                    0
                };
 
                if (u_caster->getAuraWithId(faerieFire) || u_caster->hasAurasWithId(faerieFireFeral))
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
            }
        }
    }
 
    // no problems found, so we must be ok
    return SPELL_CAST_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ canCast()

SpellCastResult Spell::canCast	(	const bool	secondCheck,
		uint32_t *	parameter1,
		uint32_t *	parameter2
	)

virtual

\ todo: need to check for units as well, like when player is controlling a creature

Reimplemented in FireNova, and DeathCoilSpell.

Definition at line 1560 of file Spell.cpp.

{
    ////////////////////////////////////////////////////////
    // Caster checks
 
    if (p_caster != nullptr)
    {
        if (!m_triggeredSpell)
        {
            if (!getSpellInfo()->isPassive())
            {
#if VERSION_STRING >= WotLK
                // You can't cast other spells if you have the player flag preventing cast
                if (p_caster->hasPlayerFlags(PLAYER_FLAG_PREVENT_SPELL_CAST))
                    return SPELL_FAILED_SPELL_IN_PROGRESS;
#endif
 
                // Check for cooldown
                if (p_caster->hasSpellOnCooldown(getSpellInfo()))
                {
                    if (m_triggeredByAura)
                        return SPELL_FAILED_DONT_REPORT;
                    else
                        return SPELL_FAILED_NOT_READY;
                }
            }
 
            // Check for global cooldown
            // but do not check it on second check
            ///\ todo: need to check for units as well, like when player is controlling a creature
            if (!secondCheck && p_caster->hasSpellGlobalCooldown(getSpellInfo()))
            {
                if (m_triggeredByAura)
                    return SPELL_FAILED_DONT_REPORT;
                else
                    return SPELL_FAILED_NOT_READY;
            }
        }
 
#if VERSION_STRING >= WotLK
        if (getSpellInfo()->getAttributesExG() & ATTRIBUTESEXG_IS_CHEAT_SPELL && !p_caster->getSession()->HasGMPermissions())
        {
            *parameter1 = SPELL_EXTRA_ERROR_GM_ONLY;
            return SPELL_FAILED_CUSTOM_ERROR;
        }
#endif
 
        // Battleground checks
        if (p_caster->getBattleground())
        {
#if VERSION_STRING >= TBC
            // Arena checks
            if (p_caster->getBattleground()->isArena())
            {
                // Spells with longer than 10 minute cooldown cannot be casted in arena
                const auto spellCooldown = getSpellInfo()->getRecoveryTime() > getSpellInfo()->getCategoryRecoveryTime() ? getSpellInfo()->getRecoveryTime() : getSpellInfo()->getCategoryRecoveryTime();
                if (getSpellInfo()->getAttributesExD() & ATTRIBUTESEXD_NOT_IN_ARENAS || (spellCooldown > 10 * MINUTE * IN_MILLISECONDS && !(getSpellInfo()->getAttributesExD() & ATTRIBUTESEXD_NOT_IN_ARENAS)))
                    return SPELL_FAILED_NOT_IN_ARENA;
            }
#endif
 
            // If battleground has ended, don't allow spell casting
            if (!m_triggeredSpell && p_caster->getBattleground()->hasEnded())
                return SPELL_FAILED_DONT_REPORT;
        }
        else if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_BG_ONLY)
        {
            return SPELL_FAILED_ONLY_BATTLEGROUNDS;
        }
 
        // Movement check
        if (p_caster->isMoving())
        {
            // No need to check for other interrupt flags, client does that for us
            // Also don't cast first ranged autorepeat spell if we're moving but activate it
            // TODO: Missing cata checks, in cata you can cast some spells while moving
            if (getSpellInfo()->isRangedAutoRepeat() || getSpellInfo()->getAuraInterruptFlags() & AURA_INTERRUPT_ON_STAND_UP)
                return SPELL_FAILED_MOVING;
        }
 
        // Prevent casting while sitting unless the spell allows it
        if (!m_triggeredSpell && p_caster->isSitting() && !(getSpellInfo()->getAttributes() & ATTRIBUTES_CASTABLE_WHILE_SITTING))
            return SPELL_FAILED_NOT_STANDING;
    }
 
    if (u_caster != nullptr)
    {
        // Check if caster is alive
        if (!u_caster->isAlive() && !(getSpellInfo()->getAttributes() & ATTRIBUTES_DEAD_CASTABLE || (m_triggeredSpell && !m_triggeredByAura)))
        {
            // but allow casting while in Spirit of Redemption form
            if (!u_caster->hasAuraWithAuraEffect(SPELL_AURA_SPIRIT_OF_REDEMPTION))
                return SPELL_FAILED_CASTER_DEAD;
        }
 
        // Check if spell requires caster to be in combat
        if (getSpellInfo()->getAttributes() & ATTRIBUTES_STOP_ATTACK && getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_UNAFFECTED_BY_SCHOOL_IMMUNITY && !u_caster->getCombatHandler().isInCombat())
            return SPELL_FAILED_CASTER_AURASTATE;
 
        auto requireCombat = true;
#if VERSION_STRING >= WotLK
        if (u_caster->hasAuraWithAuraEffect(SPELL_AURA_IGNORE_TARGET_AURA_STATE))
        {
            for (const auto& aurEff : getUnitCaster()->getAuraEffectList(SPELL_AURA_IGNORE_TARGET_AURA_STATE))
            {
                if (aurEff->getAura()->getSpellInfo()->isAuraEffectAffectingSpell(aurEff->getAuraEffectType(), getSpellInfo()))
                {
                    // Warrior's Overpower uses "combo points" based on dbc data
                    // This allows usage of Overpower if we have an affecting aura (i.e. Taste for Blood)
                    m_requiresCP = false;
 
                    // All these aura effects use effect index 0
                    // Allow Warrior's Charge to be casted on combat if caster has Juggernaut or Warbringer talent
                    if (aurEff->getAura()->getSpellInfo()->getEffectMiscValue(0) == 1)
                    {
                        requireCombat = false;
                        break;
                    }
                }
            }
        }
#endif
 
        // Caster's aura state requirements
        if (getSpellInfo()->getCasterAuraState() > 0 && !u_caster->hasAuraState(static_cast<AuraState>(getSpellInfo()->getCasterAuraState()), getSpellInfo(), u_caster))
            return SPELL_FAILED_CASTER_AURASTATE;
        if (getSpellInfo()->getCasterAuraStateNot() > 0 && u_caster->hasAuraState(static_cast<AuraState>(getSpellInfo()->getCasterAuraStateNot()), getSpellInfo(), u_caster))
            return SPELL_FAILED_CASTER_AURASTATE;
 
        // Caster's aura spell requirements
        if (getSpellInfo()->getCasterAuraSpell() > 0 && !u_caster->hasAurasWithId(getSpellInfo()->getCasterAuraSpell()))
            return SPELL_FAILED_CASTER_AURASTATE;
        if (getSpellInfo()->getCasterAuraSpellNot() > 0)
        {
            // TODO: I leave this here for now (from my old work), but this really should be moved to wotlk spellscript -Appled
            // Paladin's Avenging Wrath / Forbearance thing
            if (getSpellInfo()->getCasterAuraSpellNot() == 61988)
            {
                if (u_caster->hasAurasWithId(61987))
                    return SPELL_FAILED_CASTER_AURASTATE;
            }
            else if (u_caster->hasAurasWithId(getSpellInfo()->getCasterAuraSpellNot()))
            {
                return SPELL_FAILED_CASTER_AURASTATE;
            }
        }
 
        if (!m_triggeredSpell)
        {
            // Out of combat spells should not be able to be casted in combat
            if (requireCombat && (getSpellInfo()->getAttributes() & ATTRIBUTES_REQ_OOC) && u_caster->getCombatHandler().isInCombat())
                return SPELL_FAILED_AFFECTING_COMBAT;
 
            if (!secondCheck)
            {
                // Shapeshift check
#if VERSION_STRING >= WotLK
                auto hasIgnoreShapeshiftAura = false;
                for (const auto& aurEff : getUnitCaster()->getAuraEffectList(SPELL_AURA_IGNORE_SHAPESHIFT))
                {
                    // If aura has ignore shapeshift type, you can use spells regardless of stance / form
                    // Auras with this type: Shadow Dance, Metamorphosis, Warbringer (in 3.3.5a)
                    if (aurEff->getAura()->getSpellInfo()->isAuraEffectAffectingSpell(SPELL_AURA_IGNORE_SHAPESHIFT, getSpellInfo()))
                    {
                        hasIgnoreShapeshiftAura = true;
                        break;
                    }
                }
 
                if (!hasIgnoreShapeshiftAura)
#endif
                {
                    SpellCastResult shapeError = checkShapeshift(getSpellInfo(), u_caster->getShapeShiftForm());
                    if (shapeError != SPELL_CAST_SUCCESS)
                        return shapeError;
 
                    // Stealth check
                    if (getSpellInfo()->getAttributes() & ATTRIBUTES_REQ_STEALTH && !u_caster->hasAuraWithAuraEffect(SPELL_AURA_MOD_STEALTH))
                        return SPELL_FAILED_ONLY_STEALTHED;
                }
            }
        }
    }
 
    // Indoor and outdoor specific spells
    if (worldConfig.terrainCollision.isCollisionEnabled)
    {
        if (getSpellInfo()->getAttributes() & ATTRIBUTES_ONLY_OUTDOORS &&
            !MapManagement::AreaManagement::AreaStorage::IsOutdoor(m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ()))
            return SPELL_FAILED_ONLY_OUTDOORS;
 
        if (getSpellInfo()->getAttributes() & ATTRIBUTES_ONLY_INDOORS &&
            MapManagement::AreaManagement::AreaStorage::IsOutdoor(m_caster->GetMapId(), m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ()))
            return SPELL_FAILED_ONLY_INDOORS;
    }
 
    ////////////////////////////////////////////////////////
    // Target checks
 
    const auto explicitTargetMask = getSpellInfo()->getRequiredTargetMask(true);
 
    // Check explicit gameobject target
    if (m_targets.getGameObjectTargetGuid() != 0)
    {
        const auto objTarget = m_caster->getWorldMapGameObject(m_targets.getGameObjectTargetGuid());
        const auto targetCheck = checkExplicitTarget(objTarget, explicitTargetMask);
        if (targetCheck != SPELL_CAST_SUCCESS)
            return targetCheck;
    }
 
    // Unit target
    const auto target = m_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
    if (target != nullptr)
    {
        // Check explicit unit target
        // but skip spells with pet target here
        if (!getSpellInfo()->hasTargetType(EFF_TARGET_PET))
        {
            const auto targetCheck = checkExplicitTarget(target, explicitTargetMask);
            if (targetCheck != SPELL_CAST_SUCCESS)
                return targetCheck;
        }
 
        // Target's aura state requirements
        if (!m_triggeredSpell && getSpellInfo()->getTargetAuraState() > 0 && !target->hasAuraState(static_cast<AuraState>(getSpellInfo()->getTargetAuraState()), getSpellInfo(), u_caster))
            return SPELL_FAILED_TARGET_AURASTATE;
        if (getSpellInfo()->getTargetAuraStateNot() > 0 && target->hasAuraState(static_cast<AuraState>(getSpellInfo()->getTargetAuraState()), getSpellInfo(), u_caster))
            return SPELL_FAILED_TARGET_AURASTATE;
 
        // Target's aura spell requirements
        if (getSpellInfo()->getTargetAuraSpell() > 0 && !target->hasAurasWithId(getSpellInfo()->getTargetAuraSpell()))
            return SPELL_FAILED_TARGET_AURASTATE;
        if (getSpellInfo()->getTargetAuraSpellNot() > 0)
        {
            // TODO: I leave this here for now (from my old work), but this really should be moved to wotlk spellscript -Appled
            // Paladin's Avenging Wrath / Forbearance thing
            if (getSpellInfo()->getTargetAuraSpellNot() == 61988)
            {
                if (target->hasAurasWithId(61987))
                    return SPELL_FAILED_TARGET_AURASTATE;
            }
            else if (target->hasAurasWithId(getSpellInfo()->getTargetAuraSpellNot()))
            {
                return SPELL_FAILED_TARGET_AURASTATE;
            }
        }
 
        if (target->isCorpse())
        {
            // Player can't cast spells on corpses with bones only left
            const auto targetCorpse = sObjectMgr.getCorpseByOwner(target->getGuidLow());
            if (targetCorpse == nullptr || !targetCorpse->IsInWorld() || targetCorpse->getCorpseState() == CORPSE_STATE_BONES)
                return SPELL_FAILED_BAD_TARGETS;
        }
 
        if (getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_CANT_TARGET_SELF && m_caster == target)
            return SPELL_FAILED_BAD_TARGETS;
 
        // Check if spell requires target to be out of combat
        if (getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_REQ_OOC_TARGET && target->getCombatHandler().isInCombat())
            return SPELL_FAILED_TARGET_AFFECTING_COMBAT;
 
        if (!(getSpellInfo()->getAttributesExF() & ATTRIBUTESEXF_CAN_TARGET_INVISIBLE) && (u_caster != nullptr && !u_caster->canSee(target)))
            return SPELL_FAILED_BAD_TARGETS;
 
        if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_TARGET_ONLY_GHOSTS)
        {
            if (!target->hasAuraWithAuraEffect(SPELL_AURA_GHOST))
                return SPELL_FAILED_TARGET_NOT_GHOST;
        }
        else
        {
            if (target->hasAuraWithAuraEffect(SPELL_AURA_GHOST))
                return SPELL_FAILED_BAD_TARGETS;
        }
 
        // Check for max level
        if (getSpellInfo()->getMaxTargetLevel() != 0 && getSpellInfo()->getMaxTargetLevel() < target->getLevel())
            return SPELL_FAILED_HIGHLEVEL;
 
        // Check combo points
        if (m_requiresCP && getPlayerCaster() != nullptr)
        {
            if (!(getPlayerCaster()->getComboPoints() > 0 && getPlayerCaster()->getComboPointTarget() == target->getGuid()))
                return SPELL_FAILED_NO_COMBO_POINTS;
        }
 
        if (m_caster != target)
        {
            if (p_caster != nullptr)
            {
                // Check if caster can attack this creature type
                if (target->isCreature())
                {
                    if (!canAttackCreatureType(dynamic_cast<Creature*>(target)))
                        return SPELL_FAILED_BAD_TARGETS;
                }
 
                // Check if target is already tagged
                // Several spells cannot be casted at already tagged creatures
                // TODO: implement this error message for skinning, mining and herbalism (mining and herbalism cata only)
                if (getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_CANT_TARGET_TAGGED && target->isTagged() && !target->isTaggedByPlayerOrItsGroup(p_caster))
                    return SPELL_FAILED_CANT_CAST_ON_TAPPED;
 
                // GM flagged players should be immune to other players' casts, but not their own
                if (target->isPlayer() && (dynamic_cast<Player*>(target)->hasPlayerFlags(PLAYER_FLAG_GM) || dynamic_cast<Player*>(target)->m_isGmInvisible))
                {
#if VERSION_STRING == Classic
                    return SPELL_FAILED_BAD_TARGETS;
#else
                    return SPELL_FAILED_BM_OR_INVISGOD;
#endif
                }
 
                // Check if target can be tamed
                if (getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_TAME_BEAST)
                {
                    auto targetUnit = p_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
                    // If spell is triggered, target may need to be picked manually
                    if (targetUnit == nullptr)
                    {
                        if (p_caster->getTargetGuid() != 0)
                            targetUnit = p_caster->getWorldMapUnit(p_caster->getTargetGuid());
                    }
 
                    if (targetUnit == nullptr)
                    {
                        SendTameFailure(PETTAME_INVALIDCREATURE);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    const auto creatureTarget = targetUnit->isCreature() ? dynamic_cast<Creature*>(targetUnit) : nullptr;
                    if (creatureTarget == nullptr)
                    {
                        SendTameFailure(PETTAME_INVALIDCREATURE);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (!creatureTarget->isAlive())
                    {
                        SendTameFailure(PETTAME_DEAD);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (creatureTarget->isPet())
                    {
                        SendTameFailure(PETTAME_CREATUREALREADYOWNED);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (creatureTarget->GetCreatureProperties()->Type != UNIT_TYPE_BEAST || creatureTarget->GetCreatureProperties()->Family == 0 || !(creatureTarget->GetCreatureProperties()->typeFlags & CREATURE_FLAG1_TAMEABLE))
                    {
                        SendTameFailure(PETTAME_NOTTAMEABLE);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (p_caster->getClass() != HUNTER)
                    {
                        SendTameFailure(PETTAME_UNITSCANTTAME);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (creatureTarget->getLevel() > p_caster->getLevel())
                    {
                        SendTameFailure(PETTAME_TOOHIGHLEVEL);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (p_caster->getPet() != nullptr || !p_caster->findFreeActivePetSlot().has_value())
                    {
                        SendTameFailure(PETTAME_ANOTHERSUMMONACTIVE);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    if (p_caster->getPetCount() >= PET_SLOT_MAX_TOTAL_PET_COUNT)
                    {
                        SendTameFailure(PETTAME_TOOMANY);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
#if VERSION_STRING >= WotLK
                    // Check for Beast Mastery spell with exotic creatures
                    if (!p_caster->hasAuraWithAuraEffect(SPELL_AURA_ALLOW_TAME_PET_TYPE) && creatureTarget->IsExotic())
                    {
                        SendTameFailure(PETTAME_CANTCONTROLEXOTIC);
                        return SPELL_FAILED_DONT_REPORT;
                    }
#endif
 
                    // All good so far, check creature's family
                    const auto creatureFamily = sCreatureFamilyStore.lookupEntry(creatureTarget->GetCreatureProperties()->Family);
                    if (creatureFamily == nullptr || creatureFamily->tameable == 0)
                    {
                        SendTameFailure(PETTAME_NOTTAMEABLE);
                        return SPELL_FAILED_DONT_REPORT;
                    }
                }
            }
 
            // Do facing checks only for unit casters
            if (u_caster != nullptr)
            {
                // Target must be in front of caster
                // Check for generic ranged spells as well, if caster is player
                if (getSpellInfo()->getFacingCasterFlags() == SPELL_INFRONT_STATUS_REQUIRE_INFRONT || getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_REQ_FACING_TARGET || (getPlayerCaster() != nullptr && getSpellInfo()->getDmgClass() == SPELL_DMG_TYPE_RANGED))
                {
                    if (!u_caster->isInFront(target))
                        return SPELL_FAILED_UNIT_NOT_INFRONT;
                }
 
                // Target must be behind caster
                if (getSpellInfo()->getFacingCasterFlags() == SPELL_INFRONT_STATUS_REQUIRE_INBACK)
                {
                    if (u_caster->isInFront(target))
                        return SPELL_FAILED_UNIT_NOT_BEHIND;
                }
 
                // Caster must be behind the target
                if (getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_REQ_BEHIND_TARGET && getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_REQ_FACING_TARGET && target->isInFront(u_caster))
                {
                    // Throw spell has these attributes in 3.3.5a, ignore
                    if (getSpellInfo()->getId() != SPELL_RANGED_THROW
#if VERSION_STRING >= TBC
                        // Druid - Pounce, "Patch 2.0.3 - Pounce no longer requires the druid to be behind the target."
                        && !(getSpellInfo()->getSpellFamilyName() == SPELLFAMILY_DRUID && getSpellInfo()->getSpellFamilyFlags(0) == 0x20000)
#endif
#if VERSION_STRING >= WotLK
                        // Rogue - Mutilate, "Patch 3.0.2 - Mutilate no longer requires you be behind the target."
                        && !(getSpellInfo()->getSpellFamilyName() == SPELLFAMILY_ROGUE && getSpellInfo()->getSpellFamilyFlags(1) == 0x200000)
#endif
                        )
                        return SPELL_FAILED_NOT_BEHIND;
                }
 
                // Caster must be in front of target
                if (getSpellInfo()->getAttributes() == (ATTRIBUTES_ABILITY | ATTRIBUTES_NOT_SHAPESHIFT | ATTRIBUTES_UNK20 | ATTRIBUTES_STOP_ATTACK) && !target->isInFront(u_caster))
                    return SPELL_FAILED_NOT_INFRONT;
            }
 
            // Check if spell can be casted on dead target
            if (!((getSpellInfo()->getTargets() & (TARGET_FLAG_CORPSE | TARGET_FLAG_CORPSE2 | TARGET_FLAG_UNIT_CORPSE)) ||
                getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_CAN_BE_CASTED_ON_DEAD_TARGET) && !target->isAlive())
                return SPELL_FAILED_TARGETS_DEAD;
 
            if (target->hasAuraWithAuraEffect(SPELL_AURA_SPIRIT_OF_REDEMPTION))
                return SPELL_FAILED_BAD_TARGETS;
 
            // Line of Sight check
            if (!m_triggeredSpell && worldConfig.terrainCollision.isCollisionEnabled)
            {
                if (m_caster->IsInWorld() && !(getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_IGNORE_LINE_OF_SIGHT) && !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_SKIP_LINE_OF_SIGHT_CHECK) &&
                    (m_caster->GetMapId() != target->GetMapId() || !m_caster->IsWithinLOSInMap(target)))
                    return SPELL_FAILED_LINE_OF_SIGHT;
            }
 
            if (target->isPlayer())
            {
                // Check if target is dueling
                // but allow spell cast if target is unfriendly
                const auto targetPlayer = dynamic_cast<Player*>(target);
                if (targetPlayer->getDuelState() == DUEL_STATE_STARTED)
                {
                    if (auto* const playerOwner = getCaster()->getPlayerOwnerOrSelf())
                    {
                        if (targetPlayer->getDuelPlayer() != playerOwner && playerOwner->isFriendlyTo(targetPlayer))
                            return SPELL_FAILED_TARGET_DUELING;
                    }
                }
 
                // Check if caster or target is in a sanctuary area
                // but allow spell casting in duels
                if (auto* const playerOwner = getCaster()->getPlayerOwnerOrSelf())
                {
                    if (targetPlayer->getDuelPlayer() != playerOwner && !playerOwner->isFriendlyTo(targetPlayer))
                    {
                        if ((m_caster->GetArea() != nullptr && m_caster->GetArea()->flags & MapManagement::AreaManagement::AREA_SANCTUARY) ||
                            (targetPlayer->GetArea() != nullptr && targetPlayer->GetArea()->flags & MapManagement::AreaManagement::AREA_SANCTUARY))
                            return SPELL_FAILED_BAD_TARGETS;
                    }
                }
 
                // Do not allow spell casts on players when they are on a taxi
                // unless it's a summoning spell
                if (targetPlayer->isOnTaxi() && !getSpellInfo()->hasEffect(SPELL_EFFECT_SUMMON_PLAYER))
                    return SPELL_FAILED_BAD_TARGETS;
            }
            else if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_TARGET_ONLY_PLAYERS)
            {
                // Check only single target spells here
                // Spell target system handles this for area spells
                if (!(explicitTargetMask & SPELL_TARGET_AREA_MASK))
                    return SPELL_FAILED_TARGET_NOT_PLAYER;
            }
 
            // Check if target has stronger aura active
            const AuraCheckResponse auraCheckResponse = target->auraCheck(getSpellInfo(), m_caster);
            if (auraCheckResponse.Error == AURA_CHECK_RESULT_HIGHER_BUFF_PRESENT)
                return SPELL_FAILED_AURA_BOUNCED;
 
            // Check if target is immune to this dispel type
            //\ TODO: fix me (move to DidHit?) -Appled
            if (target->m_dispels[getSpellInfo()->getDispelType()])
                return SPELL_FAILED_IMMUNE;
        }
    }
 
    if (p_caster != nullptr)
    {
        // Check if spell requires a dead pet
        if (getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_REQ_DEAD_PET)
        {
            const auto pet = p_caster->getPet();
            if (pet != nullptr)
            {
                if (pet->isAlive())
                    return SPELL_FAILED_ALREADY_HAVE_SUMMON;
            }
            else
            {
                // Find dead pet from any active slot
                auto foundDeadPet = false;
                for (const auto& [petSlot, petId] : p_caster->getPetCachedSlotMap())
                {
                    if (petSlot >= PET_SLOT_MAX_ACTIVE_SLOT)
                        break;
 
                    const auto petCache = p_caster->getPetCache(petId);
                    if (petCache == nullptr)
                        continue;
 
                    if (!petCache->alive)
                    {
                        foundDeadPet = true;
                        // Save pet id for later use
                        add_damage = petCache->number;
                        break;
                    }
                }
 
                // todo: probably not correct error message
                if (!foundDeadPet)
                    return SPELL_FAILED_BAD_TARGETS;
            }
        }
 
        // Check if spell effect requires pet target
        for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (getSpellInfo()->getEffectImplicitTargetA(i) == EFF_TARGET_PET)
            {
                const auto pet = p_caster->getPet();
                if (pet == nullptr)
                    return m_triggeredByAura ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_NO_PET;
                else if (!pet->isAlive())
                    return m_triggeredByAura ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_TARGETS_DEAD;
                // Check Line of Sight with pets as well
                if (!m_triggeredSpell && worldConfig.terrainCollision.isCollisionEnabled)
                {
                    if (m_caster->IsInWorld() && !(getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_IGNORE_LINE_OF_SIGHT) && !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_SKIP_LINE_OF_SIGHT_CHECK) &&
                        (m_caster->GetMapId() != pet->GetMapId() || !m_caster->IsWithinLOSInMap(pet)))
                        return SPELL_FAILED_LINE_OF_SIGHT;
                }
            }
        }
    }
 
    ////////////////////////////////////////////////////////
    // Area checks
 
    // Check Line of Sight for spells with a destination
    if (m_targets.hasDestination() && !m_triggeredSpell && worldConfig.terrainCollision.isCollisionEnabled)
    {
        if (m_caster->IsInWorld() && !(getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_IGNORE_LINE_OF_SIGHT) && !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_SKIP_LINE_OF_SIGHT_CHECK) &&
            !m_caster->IsWithinLOS(m_targets.getDestination()))
            return SPELL_FAILED_LINE_OF_SIGHT;
    }
 
    if (p_caster != nullptr)
    {
        // Check if spell requires certain area
        if (getSpellInfo()->getRequiresAreaId() > 0)
        {
            auto areaEntry = p_caster->GetArea();
            if (areaEntry == nullptr)
                areaEntry = MapManagement::AreaManagement::AreaStorage::GetAreaById(p_caster->getZoneId());
            if (areaEntry == nullptr)
                return SPELL_FAILED_NOT_HERE;
 
            const auto requireAreaId = static_cast<uint32_t>(getSpellInfo()->getRequiresAreaId());
#if VERSION_STRING == TBC
            if (requireAreaId != areaEntry->id && requireAreaId != areaEntry->zone)
            {
                *parameter1 = getSpellInfo()->getRequiresAreaId();
                return SPELL_FAILED_REQUIRES_AREA;
            }
#elif VERSION_STRING >= WotLK
            auto found = false;
            auto areaGroup = sAreaGroupStore.lookupEntry(requireAreaId);
            while (areaGroup != nullptr)
            {
                for (const auto& i : areaGroup->AreaId)
                {
                    if (i == areaEntry->id || (areaEntry->zone != 0 && i == areaEntry->zone))
                    {
                        found = true;
                        *parameter1 = 0;
                        break;
                    }
                    else if (i != 0)
                    {
                        *parameter1 = i;
                    }
                }
 
                if (found || areaGroup->next_group == 0)
                    break;
 
                areaGroup = sAreaGroupStore.lookupEntry(areaGroup->next_group);
            }
 
            if (!found)
                return SPELL_FAILED_REQUIRES_AREA;
#endif
        }
 
        // Flying mount check
        if (getSpellInfo()->getAttributesExD() & ATTRIBUTESEXD_ONLY_IN_OUTLANDS)
        {
            if (!p_caster->canUseFlyingMountHere())
            {
                if (p_caster->GetMapId() != 571 || !(getSpellInfo()->getAttributesExG() & ATTRIBUTESEXG_IGNORE_COLD_WEATHER_FLYING))
                    return SPELL_FAILED_NOT_HERE;
            }
        }
 
        // Check if spell can be casted while mounted or on a taxi
        // but skip triggered and passive spells
        if ((p_caster->isMounted() || p_caster->hasUnitFlags(UNIT_FLAG_MOUNTED_TAXI)) && !m_triggeredSpell && !getSpellInfo()->isPassive())
        {
            if (p_caster->isOnTaxi())
            {
                return SPELL_FAILED_NOT_ON_TAXI;
            }
            else
            {
                if (!(getSpellInfo()->getAttributes() & ATTRIBUTES_MOUNT_CASTABLE))
                    return SPELL_FAILED_NOT_MOUNTED;
            }
        }
 
        // Check if spell can be casted in heroic dungeons or in raids
        if (getSpellInfo()->getAttributesExF() & ATTRIBUTESEXF_NOT_IN_RAIDS_OR_HEROIC_DUNGEONS)
        {
            if (p_caster->IsInWorld() && (p_caster->getWorldMap()->getBaseMap()->isRaid() || p_caster->getWorldMap()->getDifficulty() == InstanceDifficulty::DUNGEON_HEROIC))
            {
#if VERSION_STRING < WotLK
                return SPELL_FAILED_NOT_HERE;
#else
                return SPELL_FAILED_NOT_IN_RAID_INSTANCE;
#endif
            }
        }
    }
 
    ////////////////////////////////////////////////////////
    // Item, state, range and power checks
 
    const SpellCastResult itemCastResult = checkItems(parameter1, parameter2);
    if (itemCastResult != SPELL_CAST_SUCCESS)
        return itemCastResult;
 
    if (!m_triggeredSpell)
    {
        const SpellCastResult casterStateResult = checkCasterState();
        if (casterStateResult != SPELL_CAST_SUCCESS)
            return casterStateResult;
 
        const SpellCastResult rangeResult = checkRange(secondCheck);
        if (rangeResult != SPELL_CAST_SUCCESS)
            return rangeResult;
 
        const SpellCastResult powerResult = checkPower();
        if (powerResult != SPELL_CAST_SUCCESS)
            return powerResult;
    }
 
    ////////////////////////////////////////////////////////
    // Spell focus object check
 
    if (p_caster != nullptr && getSpellInfo()->getRequiresSpellFocus() > 0)
    {
        auto found = false;
        for (const auto& itr : p_caster->getInRangeObjectsSet())
        {
            if (itr == nullptr || !itr->isGameObject())
                continue;
 
            if (const auto obj = dynamic_cast<GameObject*>(itr))
            {
                if (obj->getGoType() != GAMEOBJECT_TYPE_SPELL_FOCUS)
                    continue;
 
                // Skip objects from other phases
                if (!(p_caster->GetPhase() & obj->GetPhase()))
                    continue;
 
                const auto gameObjectInfo = obj->GetGameObjectProperties();
                if (gameObjectInfo == nullptr)
                {
                    sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::canCast : Found gameobject entry {} with invalid gameobject properties, spawn id {}", obj->getEntry(), obj->getGuidLow());
                    continue;
                }
 
                // Prefer to use range from gameobject_properties instead of spell's range
                // That is required at least for profession spells since their range is set to 0 yards in DBC files
                float_t distance = 0.0f;
                if (gameObjectInfo->spell_focus.distance > 0)
                {
                    // Database seems to already have squared distances
                    distance = static_cast<float_t>(gameObjectInfo->spell_focus.distance);
                }
                else
                {
                    distance = getSpellInfo()->getMaxRange(false, p_caster, this);
                    distance *= distance;
                }
 
                // Skip objects which are out of range
                if (!p_caster->isInRange(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), distance))
                    continue;
 
                if (gameObjectInfo->spell_focus.focus_id == getSpellInfo()->getRequiresSpellFocus())
                {
                    found = true;
                    break;
                }
            }
        }
 
        if (!found)
        {
            *parameter1 = getSpellInfo()->getRequiresSpellFocus();
            return SPELL_FAILED_REQUIRES_SPELL_FOCUS;
        }
    }
 
    ////////////////////////////////////////////////////////
    // Spell target constraint check (checks if spell is castable only on certain creature or gameobject)
 
    if (m_targetConstraint != nullptr)
    {
        // Search for target constraint from within spell's max range
        float_t range = 0.0f;
        const auto rangeEntry = sSpellRangeStore.lookupEntry(getSpellInfo()->getRangeIndex());
        if (rangeEntry != nullptr)
            range = rangeEntry->maxRange;
 
        auto foundTarget = false;
 
        // Check if target needs to be a certain creature
        for (const auto& entryId : m_targetConstraint->getCreatures())
        {
            if (!m_targetConstraint->hasExplicitTarget(entryId))
            {
                // Spell requires an implicit target
                // Find closest creature with the required entry id
                const auto creatureTarget = m_caster->IsInWorld() ? m_caster->getWorldMap()->getInterface()->getCreatureNearestCoords(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), entryId) : nullptr;
                if (creatureTarget != nullptr)
                {
                    // Check that the creature is within spell's range
                    if (m_caster->isInRange(creatureTarget->GetPositionX(), creatureTarget->GetPositionY(), creatureTarget->GetPositionZ(), range * range))
                    {
                        setTargetConstraintCreature(creatureTarget);
                        foundTarget = true;
                        break;
                    }
                }
            }
            else
            {
                // Spell requires an explicit target
                // Most these spells are casted from items and then client does NOT send target guid in cast spell packet
                Unit* creatureTarget = nullptr;
                if (p_caster != nullptr)
                {
                    // If caster is player, use player's selected target
                    creatureTarget = p_caster->getWorldMapUnit(p_caster->getTargetGuid());
                }
                else if (u_caster != nullptr)
                {
                    // If caster is creature, use the one set in castSpell function
                    creatureTarget = u_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
                    if (creatureTarget == nullptr)
                        creatureTarget = u_caster->getWorldMapUnit(u_caster->getTargetGuid());
                }
 
                if (creatureTarget == nullptr)
                    continue;
 
                if (!creatureTarget->isCreature() || creatureTarget->getEntry() != entryId)
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Check that the creature is within spell's range
                if (!m_caster->isInRange(creatureTarget->GetPositionX(), creatureTarget->GetPositionY(), creatureTarget->GetPositionZ(), range * range))
                    return SPELL_FAILED_OUT_OF_RANGE;
 
                // Found target
                setTargetConstraintCreature(dynamic_cast<Creature*>(creatureTarget));
                foundTarget = true;
                break;
            }
        }
 
        // Check if target needs to be a certain gameobject
        for (const auto& entryId : m_targetConstraint->getGameObjects())
        {
            if (!m_targetConstraint->hasExplicitTarget(entryId))
            {
                // Spell requires an implicit target
                // Find closest gameobject with the required entry id
                const auto gobTarget = m_caster->IsInWorld() ? m_caster->getWorldMap()->getInterface()->getGameObjectNearestCoords(m_caster->GetPositionX(), m_caster->GetPositionY(), m_caster->GetPositionZ(), entryId) : nullptr;
                if (gobTarget != nullptr)
                {
                    // Check that the gameobject is within spell's range
                    if (m_caster->isInRange(gobTarget->GetPositionX(), gobTarget->GetPositionY(), gobTarget->GetPositionZ(), range * range))
                    {
                        setTargetConstraintGameObject(gobTarget);
                        foundTarget = true;
                    }
                }
            }
            else
            {
                // Spell requires an explicit target
                const auto objectTarget = m_caster->getWorldMapObject(m_targets.getGameObjectTargetGuid());
                if (objectTarget == nullptr)
                    continue;
 
                if (!objectTarget->isGameObject() || objectTarget->getEntry() != entryId)
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Check that the gameobject is within the spell's range
                if (!m_caster->isInRange(objectTarget->GetPositionX(), objectTarget->GetPositionY(), objectTarget->GetPositionZ(), range * range))
                    return SPELL_FAILED_OUT_OF_RANGE;
 
                // Found target
                setTargetConstraintGameObject(dynamic_cast<GameObject*>(objectTarget));
                foundTarget = true;
                break;
            }
        }
 
        if (!foundTarget)
            return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
    }
 
    ////////////////////////////////////////////////////////
    // Check for scripted cast check
 
    const SpellCastResult scriptCheck = sScriptMgr.callScriptedSpellCanCast(this, parameter1, parameter2);
    if (scriptCheck != SPELL_CAST_SUCCESS)
        return scriptCheck;
 
    ////////////////////////////////////////////////////////
    // Special checks for different spell effects
 
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (getSpellInfo()->getEffect(i))
        {
            case SPELL_EFFECT_RESURRECT:
            case SPELL_EFFECT_RESURRECT_FLAT:
            {
                if (target == nullptr)
                    return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
                if (target->isAlive())
                    return SPELL_FAILED_TARGET_NOT_DEAD;
#if VERSION_STRING >= WotLK
                if (target->hasAuraWithAuraEffect(SPELL_AURA_PREVENT_RESURRECTION))
                    return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED;
#endif
            } break;
            case SPELL_EFFECT_SUMMON:
            case SPELL_EFFECT_SUMMON_PET:
            {
                if (u_caster == nullptr)
                    break;
 
                if (u_caster->getPet() != nullptr && !(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_DISMISS_CURRENT_PET))
                {
                    if (getSpellInfo()->getEffect(i) == SPELL_EFFECT_SUMMON)
                    {
                        // Check from summon properties if this new pet is actually a pet
                        if (const auto summonProperties = sSummonPropertiesStore.lookupEntry(getSpellInfo()->getEffectMiscValueB(i)))
                        {
                            if (summonProperties->ControlType == SUMMON_CONTROL_TYPE_PET || summonProperties->Type == SUMMONTYPE_PET)
                                return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                        }
                    }
                    else
                    {
                        return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                    }
                }
 
                if (u_caster->getCharmGuid() != 0)
                    return SPELL_FAILED_ALREADY_HAVE_CHARM;
            } break;
            case SPELL_EFFECT_LEAP:
            case SPELL_EFFECT_TELEPORT_UNITS_FACE_CASTER:
            {
                if (p_caster == nullptr)
                    break;
 
                // Don't allow these effects in battlegrounds if the battleground hasn't yet started
                if (p_caster->getBattleground() && !p_caster->getBattleground()->hasStarted())
                    return SPELL_FAILED_TRY_AGAIN;
            } break;
            case SPELL_EFFECT_OPEN_LOCK:
            case SPELL_EFFECT_OPEN_LOCK_ITEM:
            {
                if (p_caster == nullptr)
                    break;
 
                uint32_t lockId = 0;
                if (m_targets.getGameObjectTargetGuid() != 0)
                {
                    const auto objectTarget = p_caster->getWorldMapGameObject(m_targets.getGameObjectTargetGuid());
                    if (objectTarget != nullptr &&
                        objectTarget->getGoType() != GAMEOBJECT_TYPE_QUESTGIVER &&
                        objectTarget->getGoType() != GAMEOBJECT_TYPE_AREADAMAGE &&
                        objectTarget->getGoType() != GAMEOBJECT_TYPE_FLAGSTAND &&
                        objectTarget->getGoType() != GAMEOBJECT_TYPE_FLAGDROP)
                    {
                        // Get lock id
                        switch (objectTarget->getGoType())
                        {
                            case GAMEOBJECT_TYPE_DOOR:
                                lockId = objectTarget->GetGameObjectProperties()->door.lock_id;
                                break;
                            case GAMEOBJECT_TYPE_BUTTON:
                                lockId = objectTarget->GetGameObjectProperties()->button.lock_id;
                                break;
                            // TODO: implement questgiver gameobjects
                            //case GAMEOBJECT_TYPE_QUESTGIVER:
                            case GAMEOBJECT_TYPE_CHEST:
                                lockId = objectTarget->GetGameObjectProperties()->chest.lock_id;
                                break;
                            case GAMEOBJECT_TYPE_TRAP:
                                lockId = objectTarget->GetGameObjectProperties()->trap.lock_id;
                                break;
                            case GAMEOBJECT_TYPE_GOOBER:
                                lockId = objectTarget->GetGameObjectProperties()->goober.lock_id;
                                break;
                            // TODO: implement areadamage gameobjects
                            //case GAMEOBJECT_TYPE_AREADAMAGE:
                            case GAMEOBJECT_TYPE_CAMERA:
                                lockId = objectTarget->GetGameObjectProperties()->camera.lock_id;
                                break;
                            // TODO: implement flagstand gameobjects
                            //case GAMEOBJECT_TYPE_FLAGSTAND:
                            case GAMEOBJECT_TYPE_FISHINGHOLE:
                                lockId = objectTarget->GetGameObjectProperties()->fishinghole.lock_id;
                                break;
                            // TODO: implement flagdrop gameobjects
                            //case GAMEOBJECT_TYPE_FLAGDROP:
                            default:
                                break;
                        }
 
                        if (lockId == 0)
                            return SPELL_FAILED_ALREADY_OPEN;
                    }
                }
                else if (m_targets.getItemTargetGuid() != 0)
                {
                    Item const* targetItem = nullptr;
                    if (m_targets.isTradeItem())
                    {
                        const auto playerTrader = p_caster->getTradeTarget();
                        if (playerTrader != nullptr)
                            targetItem = playerTrader->getTradeData()->getTradeItem(TradeSlots(m_targets.getItemTargetGuid()));
                    }
                    else
                    {
                        targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                    }
 
                    if (targetItem == nullptr)
                        return SPELL_FAILED_ITEM_GONE;
 
                    // Check if item is already unlocked
                    if (targetItem->getItemProperties()->LockId == 0 || !targetItem->m_isLocked)
                        return SPELL_FAILED_ALREADY_OPEN;
 
                    lockId = targetItem->getItemProperties()->LockId;
                }
 
                if (lockId == 0)
                    break;
 
                const auto lockInfo = sLockStore.lookupEntry(lockId);
                if (lockInfo == nullptr)
                    return SPELL_FAILED_BAD_TARGETS;
 
                auto successfulOpening = false;
                for (uint8_t x = 0; x < LOCK_NUM_CASES; ++x)
                {
                    // Check if object requires an item for unlocking
                    if (lockInfo->locktype[x] == LOCK_KEY_ITEM)
                    {
                        if (i_caster == nullptr || lockInfo->lockmisc[x] == 0)
                            continue;
                        // No need to check further on a successful match
                        if (i_caster->getEntry() == lockInfo->lockmisc[x])
                        {
                            successfulOpening = true;
                            break;
                        }
                    }
                    // Check if object requires a skill for unlocking
                    else if (lockInfo->locktype[x] == LOCK_KEY_SKILL)
                    {
                        // Check if spell's skill matches with the required skill
                        if (static_cast<uint32_t>(getSpellInfo()->getEffectMiscValue(i)) != lockInfo->lockmisc[x])
                            continue;
 
                        // Get required skill line
                        uint16_t skillId = 0;
                        switch (lockInfo->lockmisc[x])
                        {
#if VERSION_STRING <= WotLK
                            case LOCKTYPE_PICKLOCK:
                                skillId = SKILL_LOCKPICKING;
                                break;
#endif
                            case LOCKTYPE_HERBALISM:
                                skillId = SKILL_HERBALISM;
                                break;
                            case LOCKTYPE_MINING:
                                skillId = SKILL_MINING;
                                break;
                            case LOCKTYPE_FISHING:
                                skillId = SKILL_FISHING;
                                break;
#if VERSION_STRING >= WotLK
                            case LOCKTYPE_INSCRIPTION:
                                skillId = SKILL_INSCRIPTION;
                                break;
#endif
                            default:
                                break;
                        }
 
                        if (skillId != 0 || lockInfo->lockmisc[x] == LOCKTYPE_BLASTING)
                        {
                            // If item is used for opening, do not use player's skill level
                            uint32_t skillLevel = i_caster != nullptr || p_caster == nullptr ? 0 : p_caster->getSkillLineCurrent(skillId);
                            // Add skill bonuses from the spell
                            skillLevel += getSpellInfo()->calculateEffectValue(i);;
 
                            // Check for low skill level
                            if (skillLevel < lockInfo->minlockskill[x])
                                return SPELL_FAILED_LOW_CASTLEVEL;
 
#if VERSION_STRING >= WotLK
                            // Patch 3.2.0: In addition to the normal requirements, mining deposits in Northrend now require a minimum character level of 65 to mine.
                            if (p_caster)
                            {
                                if (skillId == SKILL_MINING && p_caster->GetMapId() == 571 && p_caster->getLevel() < 65)
                                {
                                    *parameter1 = SPELL_EXTRA_ERROR_NORTHREND_MINING;
                                    return SPELL_FAILED_CUSTOM_ERROR;
                                }
                            }
#endif
 
#if VERSION_STRING < Cata
                            // Check for failed attempt only at the end of cast
                            // Patch 3.1.0: You can no longer fail when Mining, Herbing, and Skinning
                            if (secondCheck && (skillId == SKILL_LOCKPICKING
#if VERSION_STRING < WotLK
                                || skillId == SKILL_HERBALISM || skillId == SKILL_MINING
#endif
                                ))
                            {
                                // Failed attempt can only happen at orange gather/pick lock and can also happen at max skill level
                                // In gathering professions orange most of the time turns to green after gaining 25 skill points
                                const auto skillDifference = skillLevel - lockInfo->minlockskill[x];
                                uint8_t failChance = 0;
                                // TODO: these values are some what correct for Classic but not confirmed
                                // need more research for TBC -Appled
                                if (skillDifference < 5)
                                    failChance = 50;
                                else if (skillDifference < 10)
                                    failChance = 35;
                                else if (skillDifference < 15)
                                    failChance = 20;
                                else if (skillDifference < 20)
                                    failChance = 10;
                                else if (skillDifference < 25)
                                    failChance = 5;
 
                                if (failChance > 0 && Util::getRandomUInt(100) < failChance)
                                    return SPELL_FAILED_TRY_AGAIN;
                            }
#endif
                        }
 
                        successfulOpening = true;
                        break;
                    }
                }
 
                if (!successfulOpening)
                    return SPELL_FAILED_BAD_TARGETS;
            } break;
            case SPELL_EFFECT_LEARN_SPELL:
            {
                if (getSpellInfo()->getEffectImplicitTargetA(i) != EFF_TARGET_PET)
                    break;
            }
            [[fallthrough]];
            case SPELL_EFFECT_LEARN_PET_SPELL:
            {
                if (p_caster == nullptr)
                    break;
 
                const auto pet = p_caster->getPet();
                if (pet == nullptr)
                    return SPELL_FAILED_NO_PET;
 
                const auto newSpell = sSpellMgr.getSpellInfo(getSpellInfo()->getEffectTriggerSpell(i));
                if (newSpell == nullptr)
                    return SPELL_FAILED_NOT_KNOWN;
 
                const auto learnStatus = pet->canLearnSpell(newSpell);
                if (learnStatus != SPELL_CAST_SUCCESS)
                    return learnStatus;
            } break;
            case SPELL_EFFECT_POWER_BURN:
            case SPELL_EFFECT_POWER_DRAIN:
            {
                if (u_caster == nullptr)
                    break;
 
                if (target == nullptr)
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Do not check further for self casts
                if (u_caster == target)
                    break;
 
                // Check for correct power type
                if (target->getMaxPower(target->getPowerType()) == 0 || target->getPowerType() != static_cast<uint8_t>(getSpellInfo()->getEffectMiscValue(i)))
                    return SPELL_FAILED_BAD_TARGETS;
            } break;
            case SPELL_EFFECT_PICKPOCKET:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
 
                if (!target->isCreature())
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Check if target is already pick pocketed
                if (dynamic_cast<Creature*>(target)->IsPickPocketed())
                    return SPELL_FAILED_TARGET_NO_POCKETS;
 
                const auto itr = sLootMgr.getPickpocketingLoot().find(target->getEntry());
                if (itr == sLootMgr.getPickpocketingLoot().end())
                    return SPELL_FAILED_TARGET_NO_POCKETS;
            } break;
#if VERSION_STRING >= WotLK
            case SPELL_EFFECT_USE_GLYPH:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
 
                const auto glyphId = static_cast<uint32_t>(getSpellInfo()->getEffectMiscValue(i));
                const auto glyphEntry = sGlyphPropertiesStore.lookupEntry(glyphId);
                if (glyphEntry == nullptr)
                    return SPELL_FAILED_INVALID_GLYPH;
 
                // Check if glyph slot is locked
                if (!(p_caster->getGlyphsEnabled() & (1 << m_glyphslot)))
                    return SPELL_FAILED_GLYPH_SOCKET_LOCKED;
 
                // Check if player already has this glyph
                if (p_caster->hasAurasWithId(glyphEntry->SpellID))
                    return SPELL_FAILED_UNIQUE_GLYPH;
            } break;
#endif
            case SPELL_EFFECT_DUEL:
            {
                if (p_caster == nullptr)
                    break;
 
                if (p_caster->GetArea() != nullptr && p_caster->GetArea()->flags & MapManagement::AreaManagement::AREA_CITY_AREA)
                    return SPELL_FAILED_NO_DUELING;
 
                if (p_caster->isStealthed())
                    return SPELL_FAILED_CANT_DUEL_WHILE_STEALTHED;
 
                if (p_caster->isInvisible())
                    return SPELL_FAILED_CANT_DUEL_WHILE_INVISIBLE;
 
                // Check if caster is in dungeon or raid
                if (p_caster->IsInWorld() && !p_caster->getWorldMap()->getBaseMap()->isWorldMap())
                    return SPELL_FAILED_NO_DUELING;
 
                const auto targetPlayer = p_caster->getWorldMapPlayer(m_targets.getUnitTargetGuid());
                if (targetPlayer != nullptr && targetPlayer->GetTransport() != p_caster->GetTransport())
                    return SPELL_FAILED_NOT_ON_TRANSPORT;
 
                if (targetPlayer != nullptr && targetPlayer->getDuelPlayer() != nullptr)
                    return SPELL_FAILED_TARGET_DUELING;
            } break;
            case SPELL_EFFECT_SUMMON_PLAYER:
            {
                if (p_caster == nullptr || target == nullptr || !target->isPlayer())
                    return SPELL_FAILED_BAD_TARGETS;
 
                const auto targetPlayer = dynamic_cast<Player*>(target);
                // Check if target is in same group/raid with the caster
                if (targetPlayer == p_caster || p_caster->getGroup() == nullptr || !p_caster->getGroup()->HasMember(targetPlayer))
                    return SPELL_FAILED_TARGET_NOT_IN_RAID;
 
                // Check if caster is in an instance map
                if (p_caster->IsInWorld() && !p_caster->getWorldMap()->getBaseMap()->isWorldMap())
                {
                    if (!p_caster->IsInMap(targetPlayer))
                        return SPELL_FAILED_TARGET_NOT_IN_INSTANCE;
 
                    const auto mapInfo = p_caster->getWorldMap()->getBaseMap()->getMapInfo();
                    if (p_caster->getWorldMap()->getDifficulty() == InstanceDifficulty::DUNGEON_HEROIC)
                    {
                        if (mapInfo->minlevel_heroic > targetPlayer->getLevel())
                            return SPELL_FAILED_LOWLEVEL;
                    }
                    else
                    {
                        if (mapInfo->minlevel > targetPlayer->getLevel())
                            return SPELL_FAILED_LOWLEVEL;
                    }
 
                    // Check if caster is in a battleground
                    if (p_caster->getWorldMap()->getBaseMap()->isBattleground() || p_caster->getBattleground())
                    {
#if VERSION_STRING == Classic
                        return SPELL_FAILED_NOT_HERE;
#else
                        return SPELL_FAILED_NOT_IN_BATTLEGROUND;
#endif
                    }
                }
            } break;
            case SPELL_EFFECT_SELF_RESURRECT:
            {
#if VERSION_STRING >= WotLK
                if (u_caster != nullptr && u_caster->hasAuraWithAuraEffect(SPELL_AURA_PREVENT_RESURRECTION))
                    return SPELL_FAILED_TARGET_CANNOT_BE_RESURRECTED;
#endif
            } break;
            case SPELL_EFFECT_SKINNING:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
 
                if (target == nullptr)
                    return SPELL_FAILED_BAD_TARGETS;
 
                if (target->isAlive())
                    return SPELL_FAILED_TARGET_NOT_DEAD;
 
                if (!target->hasUnitFlags(UNIT_FLAG_SKINNABLE) || !target->isCreature())
                    return SPELL_FAILED_TARGET_UNSKINNABLE;
 
                // Check if creature is already skinned
                const auto creatureTarget = dynamic_cast<Creature*>(target);
                if (creatureTarget->Skinned)
                    return SPELL_FAILED_TARGET_UNSKINNABLE;
 
                // Check if creature is looted
                if (creatureTarget->loot.isLooted() && creatureTarget->isTagged())
                {
                    const auto taggerPlayer = creatureTarget->getWorldMapPlayer(creatureTarget->getTaggerGuid());
                    if (taggerPlayer != nullptr && creatureTarget->HasLootForPlayer(taggerPlayer))
                        return SPELL_FAILED_TARGET_NOT_LOOTED;
                }
 
                // Check if caster has required skinning level for target
                const auto skillLevel = p_caster->getSkillLineCurrent(creatureTarget->GetRequiredLootSkill());
                // Required skinning level is calculated by multiplying the target's level by 5
                // but if player's skill level is below 100, then player's skill level is incremented by 100 and target's level is multiplied by 10
                const int32_t skillDiff = skillLevel >= 100 ? skillLevel - (creatureTarget->getLevel() * 5) : (skillLevel + 100) - (creatureTarget->getLevel() * 10);
                if (skillDiff < 0)
                    return SPELL_FAILED_LOW_CASTLEVEL;
 
#if VERSION_STRING < WotLK
                // Check for failed attempt at the end of cast
                // Patch 3.1.0: You can no longer fail when Mining, Herbing, and Skinning
                if (secondCheck)
                {
                    uint8_t failChance = 0;
                    // TODO: these values are some what correct for Classic but not confirmed
                    // need more research for TBC -Appled
                    if (skillDiff < 5)
                        failChance = 50;
                    else if (skillDiff < 10)
                        failChance = 35;
                    else if (skillDiff < 15)
                        failChance = 20;
                    else if (skillDiff < 20)
                        failChance = 10;
                    else if (skillDiff < 25)
                        failChance = 5;
 
                    if (failChance > 0 && Util::getRandomUInt(100) < failChance)
                        return SPELL_FAILED_TRY_AGAIN;
                }
#endif
            } break;
            case SPELL_EFFECT_CHARGE:
            {
                if (u_caster == nullptr)
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
 
                if (u_caster->isRooted())
                    return SPELL_FAILED_ROOTED;
 
                if (target == nullptr)
                    return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                if (worldConfig.terrainCollision.isPathfindingEnabled)
                {
                    // Check if caster is able to create path to target
                    if (!u_caster->getAIInterface()->canCreatePath(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ()))
                        return SPELL_FAILED_NOPATH;
                }
            } break;
            case SPELL_EFFECT_FEED_PET:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_BAD_TARGETS;
 
                const auto pet = p_caster->getPet();
                if (pet == nullptr)
                    return SPELL_FAILED_NO_PET;
 
                if (!pet->isAlive())
                    return SPELL_FAILED_TARGETS_DEAD;
 
                // Get the food
                const auto foodItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                if (foodItem == nullptr)
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Check if the item is food
                const auto itemProto = foodItem->getItemProperties();
                if (itemProto->FoodType == 0)
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Check if the food type matches pet's diet
                if (!(pet->getPetDiet() & (1 << (itemProto->FoodType - 1))))
                    return SPELL_FAILED_WRONG_PET_FOOD;
 
                // Check if the food level is at most 30 levels below pet's level
                if (pet->getLevel() > (itemProto->ItemLevel + 30))
                    return SPELL_FAILED_FOOD_LOWLEVEL;
            } break;
            case SPELL_EFFECT_SUMMON_DEAD_PET:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_NO_PET;
 
                // Spells with this attribute were checked already
                if (!(getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_REQ_DEAD_PET))
                {
                    const auto petTarget = p_caster->getPet();
                    if (petTarget != nullptr)
                    {
                        if (petTarget->isAlive())
                            return SPELL_FAILED_ALREADY_HAVE_SUMMON;
                    }
                    else
                    {
                        // Find dead pet from any active slot
                        auto foundDeadPet = false;
                        for (const auto& [petSlot, petId] : p_caster->getPetCachedSlotMap())
                        {
                            if (petSlot >= PET_SLOT_MAX_ACTIVE_SLOT)
                                break;
 
                            const auto petCache = p_caster->getPetCache(petId);
                            if (petCache == nullptr)
                                continue;
 
                            if (!petCache->alive)
                            {
                                foundDeadPet = true;
                                // Save pet id for later use
                                add_damage = petCache->number;
                                break;
                            }
                        }
 
                        // todo: probably not correct error message
                        if (!foundDeadPet)
                            return SPELL_FAILED_BAD_TARGETS;
                    }
                }
            } break;
            case SPELL_EFFECT_SPELL_STEAL:
            {
                if (m_targets.getUnitTargetGuid() == m_caster->getGuid())
                    return SPELL_FAILED_BAD_TARGETS;
            } break;
            default:
                break;
        }
    }
 
    ////////////////////////////////////////////////////////
    // Special checks for different aura effects
 
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        switch (getSpellInfo()->getEffectApplyAuraName(i))
        {
            case SPELL_AURA_MOD_POSSESS:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
 
                if (target == nullptr)
                    return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                if (target == p_caster)
                    return SPELL_FAILED_BAD_TARGETS;
 
                if (p_caster->getPet() != nullptr && !(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_DISMISS_CURRENT_PET))
                    return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
                if (p_caster->getCharmGuid() != 0)
                    return SPELL_FAILED_ALREADY_HAVE_CHARM;
 
                // Check if caster is charmed
                if (p_caster->getCharmedByGuid() != 0)
                    return SPELL_FAILED_CHARMED;
 
                // Check if target is already charmed
                if (target->getCharmedByGuid() != 0)
                    return SPELL_FAILED_CANT_BE_CHARMED;
 
                // Check if target is owned by player
                if (!target->isPlayer() && target->getPlayerOwner() != nullptr)
                {
#if VERSION_STRING == Classic
                    return SPELL_FAILED_BAD_TARGETS;
#else
                    return SPELL_FAILED_TARGET_IS_PLAYER_CONTROLLED;
#endif
                }
 
                if (static_cast<int32_t>(target->getLevel()) > calculateEffect(i))
                    return SPELL_FAILED_HIGHLEVEL;
            } break;
            case SPELL_AURA_MOD_CHARM:
            case SPELL_AURA_AREA_CHARM:
            {
                if (u_caster == nullptr)
                    return SPELL_FAILED_SPELL_UNAVAILABLE;
 
                if (target == nullptr)
                    return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                if (target == u_caster)
                    return SPELL_FAILED_BAD_TARGETS;
 
                if (getSpellInfo()->getEffectApplyAuraName(i) == SPELL_AURA_MOD_CHARM)
                {
                    if (p_caster != nullptr && p_caster->getPet() != nullptr && !(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_DISMISS_CURRENT_PET))
                        return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
                    // Player can have only one charm at time
                    if (p_caster != nullptr && p_caster->getCharmGuid() != 0)
                        return SPELL_FAILED_ALREADY_HAVE_CHARM;
                }
 
                // Check if caster is charmed
                if (u_caster->getCharmedByGuid() != 0)
                    return SPELL_FAILED_CHARMED;
 
                // Check if target is already charmed
                if (target->getCharmedByGuid() != 0)
                    return SPELL_FAILED_CANT_BE_CHARMED;
 
                // Check if target is owned by player
                if (!target->isPlayer() && target->getPlayerOwner() != nullptr)
                {
#if VERSION_STRING == Classic
                    return SPELL_FAILED_BAD_TARGETS;
#else
                    return SPELL_FAILED_TARGET_IS_PLAYER_CONTROLLED;
#endif
                }
 
                if (static_cast<int32_t>(target->getLevel()) > calculateEffect(i))
                    return SPELL_FAILED_HIGHLEVEL;
 
                const auto targetCreature = dynamic_cast<Creature*>(target);
                if (p_caster != nullptr && target->isCreature() && targetCreature->isTagged() && !targetCreature->isTaggedByPlayerOrItsGroup(p_caster))
                    return SPELL_FAILED_CANT_CAST_ON_TAPPED;
            } break;
            case SPELL_AURA_PERIODIC_MANA_LEECH:
            {
                // Skip for non-player and item casters
                if (p_caster == nullptr || i_caster != nullptr)
                    break;
 
                if (target != nullptr && (target->getMaxPower(POWER_TYPE_MANA) == 0 || target->getPowerType() != POWER_TYPE_MANA))
                    return SPELL_FAILED_BAD_TARGETS;
            } break;
            case SPELL_AURA_MOD_DISARM:
            {
                if (target == nullptr)
                    return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                // Check if target is not already disarmed
                if (target->getUnitFlags() & UNIT_FLAG_DISARMED)
                    return SPELL_FAILED_TARGET_NO_WEAPONS;
 
                if (target->isPlayer())
                {
                    // Check if player is even wielding a weapon
                    const auto mainHandWeapon = dynamic_cast<Player*>(target)->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                    if (mainHandWeapon == nullptr || !mainHandWeapon->isWeapon())
                        return SPELL_FAILED_TARGET_NO_WEAPONS;
                }
                else
                {
                    if (const auto creature = dynamic_cast<Creature*>(target))
                    {
                        if (const auto creatureProto = creature->GetCreatureProperties())
                        {
                            if (creatureProto->Type != UNIT_TYPE_HUMANOID && creatureProto->Type != UNIT_TYPE_DEMON &&
                                creatureProto->Type != UNIT_TYPE_GIANT && creatureProto->Type != UNIT_TYPE_UNDEAD)
                                return SPELL_FAILED_TARGET_NO_WEAPONS;
                        }
                    }
 
                    // Check if creature is even wielding a weapon
#if VERSION_STRING < WotLK
                    if (target->getVirtualItemDisplayId(MELEE) == 0)
#else
                    if (target->getVirtualItemSlotId(MELEE) == 0)
#endif
                        return SPELL_FAILED_TARGET_NO_WEAPONS;
                }
            } break;
            case SPELL_AURA_MOUNTED:
            {
                if (worldConfig.terrainCollision.isCollisionEnabled)
                {
                    if (!MapManagement::AreaManagement::AreaStorage::IsOutdoor(m_caster->GetMapId(), m_caster->GetPositionNC().x, m_caster->GetPositionNC().y, m_caster->GetPositionNC().z))
                        return SPELL_FAILED_NO_MOUNTS_ALLOWED;
                }
 
                if (p_caster != nullptr)
                {
#if VERSION_STRING == Cata
                    if (getSpellInfo()->getEffectMiscValueB(i) && !p_caster->getMountCapability(getSpellInfo()->getEffectMiscValueB(i)))
                        return SPELL_FAILED_NOT_HERE;
#endif
 
                    if (p_caster->GetTransport() != nullptr)
                        return SPELL_FAILED_NO_MOUNTS_ALLOWED;
 
                    if (p_caster->hasUnitFlags(UNIT_FLAG_LOOTING))
                    {
                        p_caster->sendMountResultPacket(ERR_MOUNT_LOOTING);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    // Check shapeshift form
                    if (p_caster->getShapeShiftForm() != FORM_NORMAL)
                    {
                        switch (p_caster->getShapeShiftForm())
                        {
                            case FORM_CAT:
                            case FORM_TREE:
                            case FORM_TRAVEL:
                            case FORM_AQUA:
                            case FORM_BEAR:
                            case FORM_GHOUL:
                            case FORM_DIREBEAR:
                            case FORM_CREATUREBEAR:
                            case FORM_CREATURECAT:
                            case FORM_GHOSTWOLF:
                            case FORM_ZOMBIE:
                            case FORM_METAMORPHOSIS:
                            case FORM_DEMON:
                            case FORM_FLIGHT:
                            case FORM_MOONKIN:
                            case FORM_SPIRITOFREDEMPTION:
                            {
                                p_caster->sendMountResultPacket(ERR_MOUNT_SHAPESHIFTED);
                                return SPELL_FAILED_DONT_REPORT;
                            } break;
                            default:
                                break;
                        }
                    }
                }
            } break;
            case SPELL_AURA_MOD_POSSESS_PET:
            {
                if (p_caster == nullptr)
                    return SPELL_FAILED_BAD_TARGETS;
 
                if (p_caster->getCharmGuid() != 0)
                    return SPELL_FAILED_ALREADY_HAVE_CHARM;
 
                if (p_caster->getCharmedByGuid() != 0)
                    return SPELL_FAILED_CHARMED;
 
                const auto petTarget = p_caster->getPet();
                if (petTarget == nullptr)
                    return SPELL_FAILED_NO_PET;
 
                if (petTarget->getCharmedByGuid() != 0)
                    return SPELL_FAILED_ALREADY_HAVE_CHARM;
            } break;
#if VERSION_STRING >= TBC
            case SPELL_AURA_FLY:
            case SPELL_AURA_ENABLE_FLIGHT2:
            {
                if (p_caster != nullptr && p_caster->isAlive())
                {
                    if (!p_caster->canUseFlyingMountHere())
                        return m_triggeredSpell ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_NOT_HERE;
                }
            } break;
            case SPELL_AURA_MIRROR_IMAGE:
            {
                // Clone effects require creature or player target
                if (target == nullptr)
                    return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
                if (target->getGuid() == m_caster->getGuid())
                    return SPELL_FAILED_BAD_TARGETS;
 
                // Cloned targets cannot be cloned
                if (target->hasAuraWithAuraEffect(SPELL_AURA_MIRROR_IMAGE))
                    return SPELL_FAILED_BAD_TARGETS;
            } break;
#endif
            default:
                break;
        }
    }
 
    if (m_targets.isTradeItem())
    {
        if (p_caster == nullptr)
            return SPELL_FAILED_SPELL_UNAVAILABLE;
 
        // Slot must be the lowest
        if (TradeSlots(m_targets.getItemTargetGuid()) != TRADE_SLOT_NONTRADED)
            return SPELL_FAILED_ITEM_NOT_FOUND;
 
        // Check if player is even trading
        if (p_caster->getTradeData() == nullptr)
            return SPELL_FAILED_NOT_TRADING;
 
        // Cast the trade spell only when both parties have accepted the trade
        const auto tradeData = p_caster->getTradeData();
        if (!tradeData->isTradeAccepted() || !tradeData->getTargetTradeData()->isTradeAccepted())
        {
            // If either one hasn't accepted the trade, save the spell and cast it on trade complete
            tradeData->setTradeSpell(getSpellInfo()->getId(), i_caster);
            return SPELL_FAILED_DONT_REPORT;
        }
    }
 
    // Call legacy CanCast for yet unhandled cases
    return m_triggeredSpell || ProcedOnSpell != nullptr ? SPELL_CAST_SUCCESS : SpellCastResult(CanCast(secondCheck));
}

Here is the caller graph for this function:

◆ cancel()

void Spell::cancel ( )

Definition at line 1394 of file Spell.cpp.

{
    switch (getState())
    {
        case SPELL_STATE_CASTING:
        {
            if (getPlayerCaster() != nullptr)
                getPlayerCaster()->clearGlobalCooldown();
 
            SendInterrupted(0);
            sendCastResult(SPELL_FAILED_INTERRUPTED);
        } break;
        case SPELL_STATE_CHANNELING:
        {
            sendChannelUpdate(0);
            SendInterrupted(0);
            sendCastResult(SPELL_FAILED_INTERRUPTED);
 
            if (getUnitCaster() != nullptr)
            {
                if (m_timer > 0 || m_Delayed)
                {
                    auto channelTarget = getUnitCaster()->getWorldMapUnit(getUnitCaster()->getChannelObjectGuid());
                    if (channelTarget == nullptr && getPlayerCaster() != nullptr)
                        channelTarget = getPlayerCaster()->getWorldMapUnit(getPlayerCaster()->getTargetGuid());
 
                    if (channelTarget != nullptr)
                        channelTarget->removeAllAurasByIdForGuid(getSpellInfo()->getId(), getCaster()->getGuid());
 
                    // Remove dynamic objects (area aura effects from Blizzard, Rain of Fire etc)
                    if (m_AreaAura)
                    {
                        const auto dynObj = getUnitCaster()->getWorldMapDynamicObject(getUnitCaster()->getChannelObjectGuid());
                        if (dynObj != nullptr)
                            dynObj->remove();
                    }
 
                    if (getPlayerCaster() != nullptr && getPlayerCaster()->getSummonedObject() != nullptr)
                    {
                        auto obj = getPlayerCaster()->getSummonedObject();
                        if (obj->IsInWorld())
                            obj->RemoveFromWorld(true);
 
                        delete obj;
                        getPlayerCaster()->setSummonedObject(nullptr);
                    }
 
                    if (m_timer > 0)
                        removeCastItem();
                }
 
                getUnitCaster()->removeAllAurasByIdForGuid(getSpellInfo()->getId(), getCaster()->getGuid());
            }
        } break;
        case SPELL_STATE_CASTED:
            break;
        default:
        {
            if (getState() == SPELL_STATE_NULL)
            {
                // just in case
                if (getCaster() != nullptr)
                    getCaster()->removeTravelingSpell(this);
                else
                    delete this;
            }
        } return;
    }
 
    // If this is true, the spell is somewhere in ::castMe() function
    // In that case, ::finish() will be called when the spell has hitted targets
    if (m_spellState != SPELL_STATE_CASTED)
        finish(false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ castMe()

void Spell::castMe ( const bool doReCheck )

Definition at line 425 of file Spell.cpp.

{
    m_spellState = SPELL_STATE_CASTED;
 
    if (DuelSpellNoMoreValid())
    {
        sendCastResult(m_triggeredSpell ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_INTERRUPTED);
        SendInterrupted(0);
        finish(false);
        return;
    }
 
    // Debug logging
    if (m_caster->isPlayer())
    {
        const auto plr = static_cast<Player*>(m_caster);
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::castMe : Player guid {} casted spell {} (id {})",
            plr->getGuidLow(), getSpellInfo()->getName(), getSpellInfo()->getId());
    }
    else if (m_caster->isCreature())
    {
        const auto creature = static_cast<Creature*>(m_caster);
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::castMe : Creature guid {} (entry {}) casted spell {} (id {})",
            creature->spawnid, creature->getEntry(), getSpellInfo()->getName(), getSpellInfo()->getId());
    }
    else
    {
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::castMe : Spell id {} casted, caster guid {}", getSpellInfo()->getId(), m_caster->getGuid());
    }
 
    // Check cast again if spell had cast time
    if (doReCheck)
    {
        // Recalculate power cost in case caster gained a mana reduction buff while casting (blizzlike)
        m_powerCost = i_caster != nullptr ? 0 : calculatePowerCost();
 
        uint32_t parameter1 = 0, parameter2 = 0;
        cancastresult = canCast(true, &parameter1, &parameter2);
        if (cancastresult != SPELL_CAST_SUCCESS)
        {
            sendCastResult(cancastresult, parameter1, parameter2);
            SendInterrupted(0);
            finish(false);
            return;
        }
    }
 
    // Remove stealth if spell is an instant cast
    if (!m_triggeredSpell && m_castTime == 0 && p_caster != nullptr)
    {
        if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NOT_BREAK_STEALTH))
            p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_STEALTH);
 
        // Remove Feign Death auras
        p_caster->removeAllAurasByAuraEffect(SPELL_AURA_FEIGN_DEATH);
    }
 
    // Initialize targets
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        const auto requiredTargetMask = getSpellInfo()->getRequiredTargetMaskForEffect(i);
        if (requiredTargetMask & SPELL_TARGET_AREA_CURTARGET)
        {
            // If target type is area around target, set destination correctly
            const auto targetObj = m_caster->getWorldMapObject(m_targets.getUnitTargetGuid());
            if (targetObj != nullptr)
            {
                m_targets.setTargetMask(TARGET_FLAG_DEST_LOCATION);
                m_targets.setDestination(targetObj->GetPosition());
            }
        }
 
        if (getSpellInfo()->getEffect(i) != 0 && getSpellInfo()->getEffect(i) != SPELL_EFFECT_PERSISTENT_AREA_AURA)
            FillTargetMap(i);
 
        // Call for scripted filter target hook
        sScriptMgr.callScriptedSpellFilterTargets(this, i, &m_effectTargets[i]);
    }
 
    // Check for magnet target (Grounding Totem)
    //\ todo: move this to ::handleeffects or something
    if (m_magnetTarget != 0)
    {
        // Spell was redirected
        // Grounding Totem gets destroyed after redirecting 1 spell
        const auto magnetTarget = m_caster->getWorldMapUnit(m_magnetTarget);
        if (magnetTarget != nullptr && magnetTarget->isCreature())
        {
            const auto creatureMagnet = static_cast<Creature*>(magnetTarget);
            if (creatureMagnet->isTotem())
                creatureMagnet->Despawn(1, 0);
        }
        m_magnetTarget = 0;
    }
 
    // Send cooldown
    if (p_caster != nullptr && !(getSpellInfo()->getAttributes() & (ATTRIBUTES_PASSIVE | ATTRIBUTES_TRIGGER_COOLDOWN)))
    {
        // Ranged shoot spells (throw, wand shoot etc) don't have cooldowns set in DBC
        // The cooldown is the speed of equipped ranged weapon
        if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_PLAYER_RANGED_SPELLS)
        {
            const auto cooldown = static_cast<int32_t>(p_caster->getBaseAttackTime(RANGED));
            p_caster->addSpellCooldown(getSpellInfo(), i_caster, this, cooldown);
        }
        else
        {
            p_caster->addSpellCooldown(getSpellInfo(), i_caster, this);
        }
    }
 
    // Take power
    if (getSpellInfo()->isOnNextMeleeAttack())
    {
        if (m_triggeredSpell)
        {
            // When on next melee spell is actually casted it will be a triggered spell
            // Need to check for power here (canCast skips power check for triggered spells)
            const auto powerResult = checkPower();
            if (powerResult != SPELL_CAST_SUCCESS)
            {
                // Normally error messages are not sent for triggered spells but this is an exception
                sendCastResult(powerResult);
                SendInterrupted(0);
                finish(false);
                return;
            }
 
            takePower();
        }
    }
    else
    {
        takePower();
    }
 
    // Remove reagents before handling effects so crafted item can be put in same slot
    removeReagents();
#if VERSION_STRING < Cata
    removeAmmo();
#endif
 
    // TODO: REMOVE ME; hackfixes from legacy Spell::castMe()
    castMeOld();
 
    // Activate on next melee spell
    // Spell is casted on next melee spell as a triggered spell
    if (getSpellInfo()->isOnNextMeleeAttack() && !m_triggeredSpell)
    {
        if (u_caster != nullptr)
        {
            if (m_triggeredByAura == nullptr && !(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NOT_BREAK_STEALTH))
            {
                // we're much better to remove this here, because otherwise spells that change powers etc,
                // don't get applied.
                u_caster->removeAllAurasByAuraInterruptFlag(AURA_INTERRUPT_ON_CAST_SPELL, getSpellInfo()->getId());
                u_caster->removeAllAurasByAuraInterruptFlag(AURA_INTERRUPT_ON_CAST);
            }
 
            u_caster->setOnMeleeSpell(getSpellInfo()->getId(), extra_cast_number);
        }
 
        finish();
        return;
    }
 
    // Fill unique hitted targets
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (getSpellInfo()->getEffect(i) == 0)
            continue;
 
        for (const auto& targetGuid : m_effectTargets[i])
        {
            if (targetGuid == 0)
                continue;
 
            // Add only if target is not already stored in the vector
            auto add = true;
            for (const auto& uniqueTarget : m_uniqueHittedTargets)
            {
                if (uniqueTarget.first == targetGuid)
                {
                    add = false;
                    break;
                }
            }
 
            if (add)
                m_uniqueHittedTargets.push_back(std::make_pair(targetGuid, DamageInfo()));
        }
    }
 
    // Cleanup missed targets; spell either hits or misses target, not both
    // Current spell target system is bullshit
    if (!m_missedTargets.empty())
    {
        for (const auto& targetGuid : m_uniqueHittedTargets)
        {
            auto missedTarget = m_missedTargets.begin();
            while (missedTarget != m_missedTargets.end())
            {
                if (missedTarget->targetGuid == targetGuid.first)
                    missedTarget = m_missedTargets.erase(missedTarget);
                else
                    ++missedTarget;
            }
        }
    }
 
    // Send spell missile/visual effect
    sendSpellGo();
 
    uint32_t channelDuration = 0;
    if (getSpellInfo()->isChanneled())
    {
        if (getDuration() > 0)
        {
            channelDuration = static_cast<uint32_t>(getDuration());
            sendChannelStart(channelDuration);
            m_spellState = SPELL_STATE_CHANNELING;
        }
        else if (getDuration() == -1)
        {
            sendChannelStart(static_cast<uint32_t>(getDuration()));
            m_spellState = SPELL_STATE_CHANNELING;
        }
    }
 
    // Set cooldown on item after SMSG_SPELL_GO
    if (i_caster != nullptr && i_caster->getOwner() != nullptr && !GetSpellFailed())
    {
        // Potion cooldown starts after leaving combat
        if (i_caster->getItemProperties()->Class == ITEM_CLASS_CONSUMABLE && i_caster->getItemProperties()->SubClass == ITEM_SUBCLASS_POTION)
        {
            i_caster->getOwner()->setLastPotion(i_caster->getItemProperties()->ItemId);
            i_caster->getOwner()->updatePotionCooldown();
        }
        else
        {
            for (uint8_t spellIndex = 0; spellIndex < MAX_ITEM_PROTO_SPELLS; ++spellIndex)
            {
                const auto& itemSpell = i_caster->getItemProperties()->Spells[spellIndex];
                if (itemSpell.Id != 0 && itemSpell.Trigger == USE)
                    i_caster->getOwner()->cooldownAddItem(i_caster->getItemProperties(), spellIndex);
            }
        }
    }
 
    // Take cast item after SMSG_SPELL_GO but before effect handling
    if (!GetSpellFailed())
        removeCastItem();
 
#if VERSION_STRING < Cata
    /*
    Five Second Rule
    After a character expends mana in casting a spell, the effective amount of mana gained per tick from spirit-based regeneration becomes a ratio of the normal
    listed above, for a period of 5 seconds. During this period mana regeneration is said to be interrupted. This is commonly referred to as the five second rule.
    By default, your interrupted mana regeneration ratio is 0%, meaning that spirit-based mana regeneration is suspended for 5 seconds after casting.
 
    Channeled spells are handled a little differently. The five second rule starts when the spell's channeling starts; i.e. when you pay the mana for it.
    The rule continues for at least five seconds, and longer if the spell is channeled for more than five seconds. For example,
    Mind Flay channels for 3 seconds and interrupts your regeneration for 5 seconds, while Tranquility channels for 10 seconds
    and interrupts your regeneration for the full 10 seconds.
    */
    if (m_usesMana && u_caster != nullptr)
        u_caster->interruptPowerRegeneration(std::max(channelDuration, 5000u));
#endif
 
    // we're much better to remove this here, because otherwise spells that change powers etc,
    // don't get applied.
    if (u_caster != nullptr && !m_triggeredSpell && m_triggeredByAura == nullptr && !(m_spellInfo->getAttributesEx() & ATTRIBUTESEX_NOT_BREAK_STEALTH))
    {
        u_caster->removeAllAurasByAuraInterruptFlag(AURA_INTERRUPT_ON_CAST_SPELL, getSpellInfo()->getId());
        u_caster->removeAllAurasByAuraInterruptFlag(AURA_INTERRUPT_ON_CAST);
    }
 
    // Prepare proc flags for caster and targets
    _prepareProcFlags();
    m_casterDamageInfo.schoolMask = SchoolMask(getSpellInfo()->getSchoolMask());
 
    // Loop through spell effects and process the spell effect on each target
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        const auto spellEffect = getSpellInfo()->getEffect(i);
        if (spellEffect == SPELL_EFFECT_NULL)
            continue;
 
        // Call for scripted before hit hook
        sScriptMgr.callScriptedSpellBeforeHit(this, i);
 
        if (!m_effectTargets[i].empty())
        {
            for (const auto& targetGuid : m_effectTargets[i])
            {
                handleHittedTarget(targetGuid, i);
            }
        }
        else
        {
            handleHittedTarget(0, i);
        }
    }
 
    // If spell applies an aura, handle it to targets after all effects have been processed
    if (!m_pendingAuras.empty())
    {
        for (auto itr = m_pendingAuras.begin(); itr != m_pendingAuras.end();)
        {
            const auto& pendingAur = *itr;
            // Handle only instant auras here
            if (pendingAur.second.travelTime > 0)
            {
                ++itr;
                continue;
            }
 
            HandleAddAura(pendingAur.first);
            itr = m_pendingAuras.erase(itr);
        }
    }
 
    // Handle targets who did not get hit by this spell (miss/resist etc)
    auto targetMissed = false, targetDodged = false, targetParried = false;
    for (const auto& missedTarget : m_missedTargets)
    {
        handleMissedTarget(missedTarget);
 
        // Check if any target missed, dodged or parried the spell
        if (missedTarget.hitResult == SPELL_DID_HIT_MISS)
            targetMissed = true;
        else if (missedTarget.hitResult == SPELL_DID_HIT_DODGE)
            targetDodged = true;
        else if (missedTarget.hitResult == SPELL_DID_HIT_PARRY)
            targetParried = true;
    }
 
    // Handle used spell modifiers
    takeUsedSpellModifiers();
 
    if (u_caster != nullptr)
    {
        // Reset attack timer
        if (!m_triggeredSpell && getSpellInfo()->getInterruptFlags() & CAST_INTERRUPT_ON_AUTOATTACK && !(getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_NOT_RESET_AUTO_ATTACKS))
        {
            u_caster->setAttackTimer(MELEE, u_caster->getBaseAttackTime(MELEE));
            //\ todo: fix this for creatures
            if (p_caster != nullptr && p_caster->hasOffHandWeapon())
                p_caster->setAttackTimer(OFFHAND, p_caster->getBaseAttackTime(OFFHAND));
        }
 
        if (p_caster != nullptr)
        {
            // Druids and rogues are refunded for 82% of the energy cost on miss, dodge or parry
            if (getSpellInfo()->getPowerType() == POWER_TYPE_ENERGY && getSpellInfo()->hasEffect(SPELL_EFFECT_ADD_COMBO_POINTS) &&
                (targetMissed || targetDodged || targetParried))
            {
                const auto refundCost = Util::float2int32(getPowerCost() * 0.82f);
                p_caster->modPower(POWER_TYPE_ENERGY, refundCost);
            }
            // Druids and warriors are refunded for 82% of the rage cost on dodge or parry
            else if (getSpellInfo()->getPowerType() == POWER_TYPE_RAGE &&
                (targetDodged || targetParried))
            {
                const auto refundCost = Util::float2int32(getPowerCost() * 0.82f);
                p_caster->modPower(POWER_TYPE_RAGE, refundCost);
            }
 
            // This is wrong but leaving this here commented out for now -Appled
            // This needs to be handled somewhere
            //Target->removeAuraStateAndAuras(static_cast<AuraState>(getSpellInfo()->getTargetAuraState()));
        }
    }
 
    // If spell is not channeled, the spell cast has finished successfully and the spell is traveling
    // Spells without travel time are also finished on next update tick
    if (m_spellState != SPELL_STATE_CHANNELING)
    {
        m_spellState = SPELL_STATE_TRAVELING;
        m_caster->addTravelingSpell(this);
    }
}

Here is the caller graph for this function:

◆ castMeOld()

void Spell::castMeOld ( )

Definition at line 852 of file Spell.Legacy.cpp.

{
    if (p_caster)
    {
        switch (getSpellInfo()->getId())
        {
            //SPELL_HASH_SLAM
            case 1464:
            case 8820:
            case 11430:
            case 11604:
            case 11605:
            case 25241:
            case 25242:
            case 34620:
            case 47474:
            case 47475:
            case 50782:
            case 50783:
            case 52026:
            case 67028:
            {
                p_caster->setAttackTimer(OFFHAND, p_caster->getBaseAttackTime(OFFHAND));
                p_caster->setAttackTimer(MELEE, p_caster->getBaseAttackTime(MELEE));
            } break;
 
            //SPELL_HASH_VICTORY_RUSH
            case 34428:
            {
                p_caster->removeAuraStateAndAuras(AURASTATE_FLAG_LASTKILLWITHHONOR);
            } break;
 
            //SPELL_HASH_HOLY_LIGHT
            case 635:
            case 639:
            case 647:
            case 1026:
            case 1042:
            case 3472:
            case 10328:
            case 10329:
            case 13952:
            case 15493:
            case 25263:
            case 25292:
            case 27135:
            case 27136:
            case 29383:
            case 29427:
            case 29562:
            case 31713:
            case 32769:
            case 37979:
            case 43451:
            case 44479:
            case 46029:
            case 48781:
            case 48782:
            case 52444:
            case 56539:
            case 58053:
            case 66112:
            case 68011:
            case 68012:
            case 68013:
            //SPELL_HASH_FLASH_OF_LIGHT
            case 19750:
            case 19939:
            case 19940:
            case 19941:
            case 19942:
            case 19943:
            case 25514:
            case 27137:
            case 33641:
            case 37249:
            case 37254:
            case 37257:
            case 48784:
            case 48785:
            case 57766:
            case 59997:
            case 66113:
            case 66922:
            case 68008:
            case 68009:
            case 68010:
            case 71930:
            {
                p_caster->removeAllAurasById(53672);
                p_caster->removeAllAurasById(54149);
            } break;
        }
 
        if (getSpellInfo()->custom_c_is_flags == SPELL_FLAG_IS_DAMAGING)
        {
            uint32_t arcanePotency[] =
            {
                //SPELL_HASH_ARCANE_POTENCY
                24544,
                31571,
                31572,
                33421,
                33713,
                57529,
                57531,
                0
            };
            if (p_caster->hasAurasWithId(arcanePotency))
            {
                p_caster->removeAllAurasById(57529);
                p_caster->removeAllAurasById(57531);
            }
        }
 
        if (p_caster->isStealthed() && !hasAttributeEx(ATTRIBUTESEX_NOT_BREAK_STEALTH)
            && getSpellInfo()->getId() != 1)  //check spells that get trigger spell 1 after spell loading
        {
            /* talents procing - don't remove stealth either */
            if (!hasAttribute(ATTRIBUTES_PASSIVE) && !(pSpellId && sSpellMgr.getSpellInfo(pSpellId)->isPassive()))
            {
                p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_STEALTH);
            }
        }
 
        // special case battleground additional actions
        if (p_caster->getBattleground())
        {
 
            // warsong gulch & eye of the storm flag pickup check
            // also includes check for trying to cast stealth/etc while you have the flag
            switch (getSpellInfo()->getId())
            {
                case 21651:
                {
                    // Arathi Basin opening spell, remove stealth, invisibility, etc.
                    p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_STEALTH);
                    p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_INVISIBILITY);
 
                    uint32_t divineShield[] =
                    {
                        //SPELL_HASH_DIVINE_SHIELD
                        642,
                        13874,
                        29382,
                        33581,
                        40733,
                        41367,
                        54322,
                        63148,
                        66010,
                        67251,
                        71550,
                        0
                    };
                    p_caster->removeAllAurasById(divineShield);
 
                    uint32_t divineProtection[] =
                    {
                        //SPELL_HASH_DIVINE_PROTECTION
                        498,
                        13007,
                        27778,
                        27779,
                        0
                    };
                    p_caster->removeAllAurasById(divineProtection);
                    //SPELL_HASH_BLESSING_OF_PROTECTION
                    p_caster->removeAllAurasById(41450);
                } break;
                case 23333:
                case 23335:
                case 34976:
                {
                    // if we're picking up the flag remove the buffs
                    p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_STEALTH);
                    p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_INVISIBILITY);
 
                    uint32_t divineShield[] =
                    {
                        //SPELL_HASH_DIVINE_SHIELD
                        642,
                        13874,
                        29382,
                        33581,
                        40733,
                        41367,
                        54322,
                        63148,
                        66010,
                        67251,
                        71550,
                        0
                    };
                    p_caster->removeAllAurasById(divineShield);
 
                    uint32_t divineProtection[] =
                    {
                        //SPELL_HASH_DIVINE_PROTECTION
                        498,
                        13007,
                        27778,
                        27779,
                        0
                    };
                    p_caster->removeAllAurasById(divineProtection);
                    //SPELL_HASH_BLESSING_OF_PROTECTION
                    p_caster->removeAllAurasById(41450);
                } break;
                // cases for stealth - etc
                // we can cast the spell, but we drop the flag (if we have it)
                case 1784:      // Stealth rank 1
                case 1785:      // Stealth rank 2
                case 1786:      // Stealth rank 3
                case 1787:      // Stealth rank 4
                case 5215:      // Prowl rank 1
                case 6783:      // Prowl rank 2
                case 9913:      // Prowl rank 3
                case 498:       // Divine protection
                case 5573:      // Unknown spell
                case 642:       // Divine shield
                case 1020:      // Unknown spell
                case 1022:      // Hand of Protection rank 1 (ex blessing of protection)
                case 5599:      // Hand of Protection rank 2 (ex blessing of protection)
                case 10278:     // Hand of Protection rank 3 (ex blessing of protection)
                case 1856:      // Vanish rank 1
                case 1857:      // Vanish rank 2
                case 26889:     // Vanish rank 3
                case 45438:     // Ice block
                case 20580:     // Unknown spell
                case 58984:     // Shadowmeld
                case 17624:     // Petrification-> http://www.wowhead.com/?spell=17624
                case 66:        // Invisibility
                    if (p_caster->getBattleground()->getType() == BattlegroundDef::TYPE_WARSONG_GULCH)
                    {
                        if (p_caster->getTeam() == 0)
                            p_caster->removeAllAurasById(23333);    // ally player drop horde flag if they have it
                        else
                            p_caster->removeAllAurasById(23335);    // horde player drop ally flag if they have it
                    }
                    if (p_caster->getBattleground()->getType() == BattlegroundDef::TYPE_EYE_OF_THE_STORM)
 
                        p_caster->removeAllAurasById(34976);        // drop the flag
                    break;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkCasterState()

SpellCastResult Spell::checkCasterState ( ) const

private

Definition at line 4114 of file Spell.cpp.

{
    // Skip for non-unit casters
    if (u_caster == nullptr)
        return SPELL_CAST_SUCCESS;
 
    // Spells with this attribute are casted regardless of caster's state or auras
    if (getSpellInfo()->getAttributesExF() & ATTRIBUTESEXF_IGNORE_CASTER_STATE_AND_AURAS)
        return SPELL_CAST_SUCCESS;
 
    // Spells that have following attributes should be casted regardless of caster's state
    // Includes tons of quest and achievement credit spells, and some battleground spells (flag drops, marks, honor spells)
    if (getSpellInfo()->getAttributes() & ATTRIBUTES_DEAD_CASTABLE &&
        getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_IGNORE_LINE_OF_SIGHT &&
        getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_HIGH_PRIORITY)
        return SPELL_CAST_SUCCESS;
 
    uint16_t schoolImmunityMask = 0, dispelImmunityMask = 0;
    uint32_t mechanicImmunityMask = 0;
    if (getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_DISPEL_AURAS_ON_IMMUNITY)
    {
        for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            switch (getSpellInfo()->getEffectApplyAuraName(i))
            {
                case SPELL_AURA_SCHOOL_IMMUNITY:
                    // This is already stored in bitmask
                    schoolImmunityMask |= static_cast<uint16_t>(getSpellInfo()->getEffectMiscValue(i));
                    break;
                case SPELL_AURA_MECHANIC_IMMUNITY:
                    mechanicImmunityMask |= 1 << static_cast<uint32_t>(getSpellInfo()->getEffectMiscValue(i) - 1);
                    break;
                case SPELL_AURA_MECHANIC_IMMUNITY_MASK:
                    mechanicImmunityMask |= static_cast<uint32_t>(getSpellInfo()->getEffectMiscValue(i));
                    break;
                case SPELL_AURA_DISPEL_IMMUNITY:
                {
                    const uint16_t dispelMaskAll = (1 << DISPEL_MAGIC) | (1 << DISPEL_CURSE) | (1 << DISPEL_DISEASE) | (1 << DISPEL_POISON);
                    dispelImmunityMask |= getSpellInfo()->getEffectMiscValue(i) == DISPEL_ALL ? dispelMaskAll : static_cast<uint16_t>(1 << getSpellInfo()->getEffectMiscValue(i));
                } break;
                default:
                    break;
            }
        }
 
        // Check if the spell is a pvp trinket alike spell (removes all movement impairement and loss of control effects)
        if (getSpellInfo()->getEffectApplyAuraName(0) == SPELL_AURA_MECHANIC_IMMUNITY &&
            getSpellInfo()->getEffectMiscValue(0) == 1 &&
            getSpellInfo()->getEffectApplyAuraName(1) == 0 && getSpellInfo()->getEffectApplyAuraName(2) == 0)
            mechanicImmunityMask = MOVEMENT_IMPAIRMENTS_AND_LOSS_OF_CONTROL_MASK;
    }
 
    // Helper lambda for checking if spell has a mechanic
    const auto hasSpellMechanic = [](SpellInfo const* spellInfo, SpellMechanic mechanic) -> bool
    {
        if (spellInfo->getMechanicsType() == mechanic)
            return true;
 
        for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (spellInfo->getEffectMechanic(i) == mechanic)
                return true;
        }
 
        return false;
    };
 
    SpellCastResult errorMsg = SPELL_CAST_SUCCESS;
    if (u_caster->hasUnitStateFlag(UNIT_STATE_STUNNED))
    {
        if (getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_USABLE_WHILE_STUNNED)
        {
            // Spell is usable while stunned, but there are some spells with stun effect which are not classified as normal stun spells
            for (const auto& aurEff : getUnitCaster()->getAuraEffectList(SPELL_AURA_MOD_STUN))
            {
                const auto* stunAura = aurEff->getAura();
                // Frozen mechanic acts like stunned mechanic
                if (!hasSpellMechanic(stunAura->getSpellInfo(), MECHANIC_STUNNED)
                    && !hasSpellMechanic(stunAura->getSpellInfo(), MECHANIC_FROZEN))
                {
                    // The stun aura has a stun effect but has no stun or frozen mechanic
                    // This is not a normal stun aura
                    errorMsg = SPELL_FAILED_STUNNED;
                    break;
                }
            }
        }
        else
        {
            errorMsg = SPELL_FAILED_STUNNED;
        }
    }
    else if (u_caster->hasUnitStateFlag(UNIT_STATE_CONFUSED) && !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_USABLE_WHILE_CONFUSED))
    {
        errorMsg = SPELL_FAILED_CONFUSED;
    }
    else if (u_caster->hasUnitStateFlag(UNIT_STATE_FLEEING) && !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_USABLE_WHILE_FEARED))
    {
        errorMsg = SPELL_FAILED_FLEEING;
    }
    else if (u_caster->hasUnitFlags(UNIT_FLAG_SILENCED) && getSpellInfo()->getPreventionType() == PREVENTION_TYPE_SILENCE)
    {
        errorMsg = SPELL_FAILED_SILENCED;
    }
    else if (u_caster->hasUnitStateFlag(UNIT_FLAG_PACIFIED) && getSpellInfo()->getPreventionType() == PREVENTION_TYPE_PACIFY)
    {
        errorMsg = SPELL_FAILED_PACIFIED;
    }
 
    if (errorMsg != SPELL_CAST_SUCCESS)
    {
        if (schoolImmunityMask > 0 || dispelImmunityMask > 0 || mechanicImmunityMask > 0)
        {
            // The spell cast is prevented by some state but check if the spell is unaffected by those states or grants immunity to those states
            for (const auto& aur : getUnitCaster()->getAuraList())
            {
                if (aur == nullptr)
                    continue;
 
                // Check if the spell, which is being casted, is unaffected by this aura due to school immunity
                if (aur->getSpellInfo()->getSchoolMask() & schoolImmunityMask && !(aur->getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_UNAFFECTED_BY_SCHOOL_IMMUNE))
                    continue;
 
                // Check if the spell, which is being casted, is unaffected by this aura due to dispel immunity
                if ((1 << aur->getSpellInfo()->getDispelType()) & dispelImmunityMask)
                    continue;
 
                for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    if (aur->getSpellInfo()->getEffectApplyAuraName(i) == 0)
                        continue;
 
                    // Get aura's mechanics in one mask
                    uint32_t mechanicMask = 0;
                    if (aur->getSpellInfo()->getMechanicsType() > 0)
                        mechanicMask |= 1 << (aur->getSpellInfo()->getMechanicsType() - 1);
                    if (aur->getSpellInfo()->getEffectMechanic(i) > 0)
                        mechanicMask |= 1 << (aur->getSpellInfo()->getEffectMechanic(i) - 1);
 
                    // Check if the spell, which is being casted, is unaffected by this aura due to mechanic immunity
                    if (mechanicMask & mechanicImmunityMask)
                        continue;
 
                    // Spell cast is prevented by this aura and by this effect index, return correct error message
                    switch (aur->getSpellInfo()->getEffectApplyAuraName(i))
                    {
                        case SPELL_AURA_MOD_STUN:
                            if (!(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_USABLE_WHILE_STUNNED) || !hasSpellMechanic(getSpellInfo(), MECHANIC_STUNNED))
                                return SPELL_FAILED_STUNNED;
                            break;
                        case SPELL_AURA_MOD_CONFUSE:
                            if (!(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_USABLE_WHILE_CONFUSED))
                                return SPELL_FAILED_CONFUSED;
                            break;
                        case SPELL_AURA_MOD_FEAR:
                            if (!(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_USABLE_WHILE_FEARED))
                                return SPELL_FAILED_FLEEING;
                            break;
                        case SPELL_AURA_MOD_SILENCE:
                        case SPELL_AURA_MOD_PACIFY:
                        case SPELL_AURA_MOD_PACIFY_SILENCE:
                            if (getSpellInfo()->getPreventionType() == PREVENTION_TYPE_SILENCE)
                                return SPELL_FAILED_SILENCED;
                            if (getSpellInfo()->getPreventionType() == PREVENTION_TYPE_PACIFY)
                                return SPELL_FAILED_PACIFIED;
                            break;
                        default:
                            break;
                    }
                }
            }
        }
        else
        {
            // Spell cast is prevented by some state and the spell does not grant immunity to that state
            return errorMsg;
        }
    }
 
    return SPELL_CAST_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkExplicitTarget()

SpellCastResult Spell::checkExplicitTarget	(	Object *	target,
		uint32_t	requiredTargetMask
	)		const

private

Definition at line 5705 of file Spell.cpp.

{
    if (target == nullptr || !target->IsInWorld())
        return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
    // Check if spell requires only gameobject targets
    if (requiredTargetMask == SPELL_TARGET_REQUIRE_GAMEOBJECT)
    {
        if (!target->isGameObject())
            return SPELL_FAILED_BAD_TARGETS;
    }
 
    // Check if spell requires either gameobject or item target
    if (requiredTargetMask == (SPELL_TARGET_REQUIRE_GAMEOBJECT | SPELL_TARGET_REQUIRE_ITEM))
    {
        if (!target->isGameObject() && !target->isItem())
            return SPELL_FAILED_BAD_TARGETS;
    }
 
    // Check if spell can target gameobjects
    if (target->isGameObject() && !m_triggeredSpell && !(requiredTargetMask & SPELL_TARGET_OBJECT_SCRIPTED) && !(requiredTargetMask & SPELL_TARGET_REQUIRE_GAMEOBJECT))
        return SPELL_FAILED_BAD_TARGETS;
 
    // Check if spell can target items
    if (target->isItem() && !m_triggeredSpell && !(requiredTargetMask & SPELL_TARGET_REQUIRE_ITEM))
        return SPELL_FAILED_BAD_TARGETS;
 
    // Check if spell can target friendly unit
    if (requiredTargetMask & SPELL_TARGET_REQUIRE_FRIENDLY && !m_caster->isFriendlyTo(target))
        return SPELL_FAILED_BAD_TARGETS;
 
    // Check if spell can target attackable unit
    if (requiredTargetMask & SPELL_TARGET_REQUIRE_ATTACKABLE && !(requiredTargetMask & SPELL_TARGET_AREA_SELF && m_caster == target) && !m_caster->isValidTarget(target, getSpellInfo()))
        return SPELL_FAILED_BAD_TARGETS;
 
    if (requiredTargetMask & SPELL_TARGET_OBJECT_TARCLASS)
    {
        const auto* const originalTarget = m_caster->getWorldMapObject(m_targets.getUnitTargetGuid());
        if (originalTarget == nullptr)
            return SPELL_FAILED_BAD_TARGETS;
        if (originalTarget->isPlayer() != target->isPlayer())
            return SPELL_FAILED_BAD_TARGETS;
        if ((originalTarget->isPlayer() && target->isPlayer() && static_cast<Player const*>(originalTarget)->getClass() != static_cast<Player const*>(target)->getClass()))
            return SPELL_FAILED_BAD_TARGETS;
    }
 
    // Check if spell requires pet target
    if (requiredTargetMask & SPELL_TARGET_OBJECT_CURPET && !target->isPet())
    {
        // If spell also requires item target, check for item
        if (requiredTargetMask & SPELL_TARGET_REQUIRE_ITEM)
        {
            if (!target->isItem())
                return SPELL_FAILED_BAD_TARGETS;
        }
        else
        {
            return SPELL_FAILED_BAD_TARGETS;
        }
    }
 
    // Area spells cannot target totems or dead units unless spell caster is the target
    if (m_caster != target &&
        ((target->isCreatureOrPlayer() && !static_cast<Unit const*>(target)->isAlive()) || (target->isCreature() && target->isTotem()))
        && (requiredTargetMask & (SPELL_TARGET_AREA | SPELL_TARGET_AREA_SELF | SPELL_TARGET_AREA_CURTARGET | SPELL_TARGET_AREA_CONE | SPELL_TARGET_AREA_PARTY | SPELL_TARGET_AREA_RAID)))
        return SPELL_FAILED_BAD_TARGETS;
 
    return SPELL_CAST_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkItems()

SpellCastResult Spell::checkItems	(	uint32_t *	parameter1,
		uint32_t *	parameter2
	)		const

private

Definition at line 3295 of file Spell.cpp.

{
    // Skip for non-player casters
    if (p_caster == nullptr)
        return SPELL_CAST_SUCCESS;
 
    // If spell is casted from an enchant scroll
    auto scrollItem = false;
    // If spell is casted on an armor vellum or on a weapon vellum
    auto vellumTarget = false;
 
    // Casted by an item
    if (i_caster != nullptr)
    {
        if (!p_caster->hasItem(i_caster->getEntry()))
            return SPELL_FAILED_ITEM_GONE;
 
        // Check if the item is in trade window
        if (p_caster->getTradeData() != nullptr && p_caster->getTradeData()->hasPlayerOrTraderItemInTrade(i_caster->getGuid()))
            return SPELL_FAILED_NOT_WHILE_TRADING;
 
        const auto itemProperties = i_caster->getItemProperties();
        if (itemProperties == nullptr)
            return SPELL_FAILED_ITEM_GONE;
 
        // Check if the item is an enchant scroll
        if (itemProperties->Flags & ITEM_FLAG_ENCHANT_SCROLL)
            scrollItem = true;
 
        // Check if the item has any charges left
        for (uint8_t i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
        {
            if (itemProperties->Spells[i].Charges > 0 && i_caster->getSpellCharges(i) == 0)
                return SPELL_FAILED_NO_CHARGES_REMAIN;
        }
 
#if VERSION_STRING < WotLK
        // Check zone
        if (itemProperties->ZoneNameID > 0 && itemProperties->ZoneNameID != p_caster->getZoneId())
            return SPELL_FAILED_NOT_HERE;
        // Check map
        if (itemProperties->MapID > 0 && itemProperties->MapID != p_caster->GetMapId())
            return SPELL_FAILED_NOT_HERE;
#else
        // Check zone
        if (itemProperties->ZoneNameID > 0 && itemProperties->ZoneNameID != p_caster->getZoneId())
            return SPELL_FAILED_INCORRECT_AREA;
        // Check map
        if (itemProperties->MapID > 0 && itemProperties->MapID != p_caster->GetMapId())
            return SPELL_FAILED_INCORRECT_AREA;
#endif
 
        if (getSpellInfo()->getAuraInterruptFlags() & AURA_INTERRUPT_ON_STAND_UP)
        {
            if (p_caster->getCombatHandler().isInCombat())
            {
                p_caster->getItemInterface()->buildInventoryChangeError(i_caster, nullptr, INV_ERR_CANT_DO_IN_COMBAT);
                return SPELL_FAILED_DONT_REPORT;
            }
            else if (p_caster->isMounted())
            {
                return SPELL_FAILED_NOT_MOUNTED;
            }
        }
 
        // Check health and power for consumables (potions, healthstones, mana items etc)
        if (itemProperties->Class == ITEM_CLASS_CONSUMABLE)
        {
            const auto targetUnit = p_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
            if (targetUnit != nullptr)
            {
                SpellCastResult errorMessage = SPELL_CAST_SUCCESS;
                for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
                {
                    // Pet related effects are handled later
                    if (getSpellInfo()->getEffectImplicitTargetA(i) == EFF_TARGET_PET)
                        continue;
 
                    // +HP items
                    if (getSpellInfo()->getEffect(i) == SPELL_EFFECT_HEAL)
                    {
                        // Check if target has full health
                        if (targetUnit->getHealthPct() == 100)
                        {
                            errorMessage = SPELL_FAILED_ALREADY_AT_FULL_HEALTH;
                            continue;
                        }
                        else
                        {
                            errorMessage = SPELL_CAST_SUCCESS;
                            break;
                        }
                    }
 
                    // +Mana/Power items
                    if (getSpellInfo()->getEffect(i) == SPELL_EFFECT_ENERGIZE)
                    {
                        // Check if the spell has valid power type
                        if (getSpellInfo()->getEffectMiscValue(i) < 0 || getSpellInfo()->getEffectMiscValue(i) >= TOTAL_PLAYER_POWER_TYPES)
                        {
                            errorMessage = SPELL_FAILED_ALREADY_AT_FULL_POWER;
                            continue;
                        }
 
                        // Check if target has full powers
                        const auto powerType = static_cast<PowerType>(getSpellInfo()->getEffectMiscValue(i));
                        if (targetUnit->getPowerPct(powerType) == 100)
                        {
#if VERSION_STRING == Classic
                            errorMessage = SPELL_FAILED_ALREADY_AT_FULL_POWER;
#else
                            errorMessage = powerType == POWER_TYPE_MANA ? SPELL_FAILED_ALREADY_AT_FULL_MANA : SPELL_FAILED_ALREADY_AT_FULL_POWER;
#endif
                            continue;
                        }
                        else
                        {
                            errorMessage = SPELL_CAST_SUCCESS;
                            break;
                        }
                    }
                }
 
                if (errorMessage != SPELL_CAST_SUCCESS)
                    return errorMessage;
            }
        }
 
        // Check if item can be used while in shapeshift form
        if (p_caster->getShapeShiftForm() != FORM_NORMAL)
        {
            const auto shapeShift = sSpellShapeshiftFormStore.lookupEntry(p_caster->getShapeShiftForm());
            if (shapeShift != nullptr && !(shapeShift->Flags & 1))
            {
                if (!(i_caster->getItemProperties()->Flags & ITEM_FLAG_SHAPESHIFT_OK))
                    return SPELL_FAILED_NO_ITEMS_WHILE_SHAPESHIFTED;
            }
        }
    }
 
    // Casted on an item
    if (m_targets.getItemTargetGuid() > 0)
    {
        Item* targetItem = nullptr;
        // Check if the targeted item is in the trade window
        if (m_targets.isTradeItem())
        {
            // Only enchanting and lockpicking effects can be used in trade window
            if (getSpellInfo()->getEffect(0) == SPELL_EFFECT_OPEN_LOCK ||
                getSpellInfo()->getEffect(0) == SPELL_EFFECT_ENCHANT_ITEM ||
                getSpellInfo()->getEffect(0) == SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY)
            {
                if (getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_ENCHANT_OWN_ONLY)
                    return SPELL_FAILED_NOT_TRADEABLE;
 
                if (p_caster->getTradeTarget() != nullptr)
                    targetItem = p_caster->getTradeTarget()->getTradeData()->getTradeItem(TradeSlots(m_targets.getItemTargetGuid()));
            }
            else
            {
                return SPELL_FAILED_NOT_TRADEABLE;
            }
        }
        else
        {
            targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
        }
 
        if (targetItem == nullptr)
            return SPELL_FAILED_ITEM_GONE;
 
        // Check explicit item target
        const auto targetCheck = checkExplicitTarget(targetItem, getSpellInfo()->getRequiredTargetMask(true));
        if (targetCheck != SPELL_CAST_SUCCESS)
            return targetCheck;
 
        if (!targetItem->fitsToSpellRequirements(getSpellInfo()))
            return SPELL_FAILED_BAD_TARGETS;
 
        // Prevent exploiting (enchanting broken items and stacking them)
        if (targetItem->getDurability() == 0 && targetItem->getMaxDurability() != 0)
            return SPELL_FAILED_BAD_TARGETS;
 
        if ((getSpellInfo()->getEquippedItemClass() == ITEM_CLASS_ARMOR && targetItem->getItemProperties()->Class == ITEM_CLASS_TRADEGOODS && targetItem->getItemProperties()->SubClass == ITEM_SUBCLASS_ARMOR_ENCHANTMENT) ||
            (getSpellInfo()->getEquippedItemClass() == ITEM_CLASS_WEAPON && targetItem->getItemProperties()->Class == ITEM_CLASS_TRADEGOODS && targetItem->getItemProperties()->SubClass == ITEM_SUBCLASS_WEAPON_ENCHANTMENT))
            vellumTarget = true;
    }
    // Spell requires an item to be equipped
    else if (m_targets.getItemTargetGuid() == 0 && getSpellInfo()->getEquippedItemClass() >= 0)
    {
        auto hasItemWithProperType = false;
        switch (getSpellInfo()->getEquippedItemClass())
        {
            // Spell requires a melee weapon or a ranged weapon
            case ITEM_CLASS_WEAPON:
            {
                for (int16_t i = EQUIPMENT_SLOT_MAINHAND; i <= EQUIPMENT_SLOT_RANGED; ++i)
                {
                    const auto inventoryItem = p_caster->getItemInterface()->GetInventoryItem(i);
                    if (inventoryItem != nullptr)
                    {
                        // Check if the weapon slot is disarmed
                        if ((i == EQUIPMENT_SLOT_MAINHAND && p_caster->hasUnitFlags(UNIT_FLAG_DISARMED))
#if VERSION_STRING >= WotLK
                            || (i == EQUIPMENT_SLOT_OFFHAND && p_caster->hasUnitFlags2(UNIT_FLAG2_DISARM_OFFHAND))
                            || (i == EQUIPMENT_SLOT_RANGED && p_caster->hasUnitFlags2(UNIT_FLAG2_DISARM_RANGED))
#endif
                            )
                            continue;
 
                        // Check for proper item class and subclass
                        if (inventoryItem->fitsToSpellRequirements(getSpellInfo()))
                        {
                            hasItemWithProperType = true;
                            break;
                        }
                    }
                }
            } break;
            // Spell requires an armor piece (like shield)
            case ITEM_CLASS_ARMOR:
            {
                // Check first if spell requires a shield equipped
                Item* inventoryItem;
                if (getSpellInfo()->getEquippedItemSubClass() & (1 << ITEM_SUBCLASS_ARMOR_SHIELD))
                {
                    inventoryItem = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_OFFHAND);
                    if (inventoryItem != nullptr)
                    {
#if VERSION_STRING >= WotLK
                        // Check for offhand disarm
                        if (!p_caster->hasUnitFlags2(UNIT_FLAG2_DISARM_OFFHAND))
#endif
                        {
                            // Check for proper item class and subclass
                            if (inventoryItem->fitsToSpellRequirements(getSpellInfo()))
                            {
                                hasItemWithProperType = true;
                                break;
                            }
                        }
                    }
                }
 
                // Check for other armor pieces
                for (int16_t i = EQUIPMENT_SLOT_HEAD; i < EQUIPMENT_SLOT_MAINHAND; ++i)
                {
                    inventoryItem = p_caster->getItemInterface()->GetInventoryItem(i);
                    if (inventoryItem != nullptr)
                    {
                        // Check for proper item class and subclass
                        if (inventoryItem->fitsToSpellRequirements(getSpellInfo()))
                        {
                            hasItemWithProperType = true;
                            break;
                        }
                    }
                }
 
                // No need to check further if found already
                if (hasItemWithProperType)
                    break;
 
                // Ranged slot can have an item classified as armor (no need to check for disarm in these cases)
                inventoryItem = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
                if (inventoryItem != nullptr)
                {
                    // Check for proper item class and subclass
                    if (inventoryItem->fitsToSpellRequirements(getSpellInfo()))
                    {
                        hasItemWithProperType = true;
                        break;
                    }
                }
            } break;
            default:
                break;
        }
 
        // These triggered learn spell effects shouldn't fail here
        if (m_triggeredSpell)
        {
            for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                const auto eff = getSpellInfo()->getEffect(i);
                if (eff == SPELL_EFFECT_NULL)
                    continue;
 
                if (eff == SPELL_EFFECT_BLOCK || eff == SPELL_EFFECT_WEAPON || eff == SPELL_EFFECT_PROFICIENCY)
                {
                    hasItemWithProperType = true;
                    break;
                }
            }
        }
 
        if (!hasItemWithProperType)
        {
            *parameter1 = static_cast<uint32_t>(getSpellInfo()->getEquippedItemClass());
            *parameter2 = static_cast<uint32_t>(getSpellInfo()->getEquippedItemSubClass());
            return SPELL_FAILED_EQUIPPED_ITEM_CLASS;
        }
 
        // Temporary helper lambda
        const auto hasEquippableWeapon = [&](Item const* weapon) -> bool
        {
            if (weapon == nullptr)
                return false;
            if (weapon->getItemProperties()->MaxDurability > 0 && weapon->getDurability() == 0)
                return false;
            return weapon->fitsToSpellRequirements(getSpellInfo());
        };
 
        // Check if spell explicitly requires a main hand weapon
        if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_REQUIRES_MAIN_HAND_WEAPON)
        {
            if (!hasEquippableWeapon(p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND)))
                return SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND;
        }
 
        // Check if spell explicitly requires an offhand weapon
        if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_REQUIRES_OFFHAND_WEAPON)
        {
            if (!hasEquippableWeapon(p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_OFFHAND)))
                return SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND;
        }
    }
 
    // Check if the spell requires any reagents or tools (skip enchant scrolls)
    if (i_caster == nullptr || !(i_caster->getItemProperties()->Flags & ITEM_FLAG_ENCHANT_SCROLL))
    {
#if VERSION_STRING == Classic
        auto checkForReagents = true;
#else
        // Spells with ATTRIBUTESEXE_REAGENT_REMOVAL attribute won't take reagents if player has UNIT_FLAG_NO_REAGANT_COST flag
        auto checkForReagents = !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_REAGENT_REMOVAL && p_caster->hasUnitFlags(UNIT_FLAG_NO_REAGANT_COST));
#endif
        if (checkForReagents)
        {
#if VERSION_STRING >= WotLK
            // Check for spells which remove the reagent cost for a spell
            // e.g. Glyph of Slow Fall or Glyph of Levitate
            for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (getSpellInfo()->getSpellFamilyFlags(i) == 0)
                    continue;
                if (getSpellInfo()->getSpellFamilyFlags(i) & p_caster->getNoReagentCost(i))
                {
                    checkForReagents = false;
                    break;
                }
            }
#endif
        }
        // Reagents will always be checked for items in trade window
        else if (m_targets.getItemTargetGuid() != 0 && m_targets.isTradeItem())
        {
            checkForReagents = true;
        }
 
        if (checkForReagents)
        {
            for (uint8_t i = 0; i < MAX_SPELL_REAGENTS; ++i)
            {
                if (getSpellInfo()->getReagent(i) == 0)
                    continue;
 
                const auto itemId = static_cast<uint32_t>(getSpellInfo()->getReagent(i));
                auto itemCount = getSpellInfo()->getReagentCount(i);
 
                // Some spells include the used item as one of the reagents
                // So in these cases itemCount must be incremented by one
                // e.g. item id 24502 requires 7 items but DBC data requires only 6, because the one missing item is the caster
                if (i_caster != nullptr && i_caster->getEntry() == itemId)
                {
                    const auto itemProperties = i_caster->getItemProperties();
                    for (uint8_t x = 0; x < MAX_ITEM_PROTO_SPELLS; ++x)
                    {
                        if (itemProperties->Spells[x].Id == 0)
                            continue;
                        if (itemProperties->Spells[x].Charges == -1 && i_caster->getSpellCharges(x) <= 1)
                        {
                            ++itemCount;
                            break;
                        }
                    }
                }
 
                if (!p_caster->hasItem(itemId, itemCount))
                {
#if VERSION_STRING == Classic
                    //\ todo: figure out correct error message
                    return SPELL_FAILED_ITEM_NOT_READY;
#else
                    *parameter1 = itemId;
                    return SPELL_FAILED_REAGENTS;
#endif
                }
            }
        }
 
        // Check for totem items
        for (uint8_t i = 0; i < MAX_SPELL_TOTEMS; ++i)
        {
            if (getSpellInfo()->getTotem(i) != 0)
            {
                if (!p_caster->hasItem(getSpellInfo()->getTotem(i)))
                {
#if VERSION_STRING == Classic
                    //\ todo: figure out correct error message
                    return SPELL_FAILED_ITEM_NOT_READY;
#else
                    *parameter1 = getSpellInfo()->getTotem(i);
                    return SPELL_FAILED_TOTEMS;
#endif
                }
            }
        }
 
#if VERSION_STRING >= TBC
        // Check for totem category items
        for (uint8_t i = 0; i < MAX_SPELL_TOTEM_CATEGORIES; ++i)
        {
            if (getSpellInfo()->getTotemCategory(i) != 0 && !p_caster->getItemInterface()->hasItemForTotemCategory(getSpellInfo()->getTotemCategory(i)))
            {
                *parameter1 = getSpellInfo()->getTotemCategory(i);
                return SPELL_FAILED_TOTEM_CATEGORY;
            }
        }
#endif
    }
 
    // Special checks for different spell effects
    for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (getSpellInfo()->getEffect(i) == 0)
            continue;
 
        switch (getSpellInfo()->getEffect(i))
        {
            case SPELL_EFFECT_CREATE_ITEM:
#if VERSION_STRING >= WotLK
            case SPELL_EFFECT_CREATE_ITEM2:
#endif
                if (getSpellInfo()->getEffectItemType(i) != 0)
                {
                    const auto itemProperties = sMySQLStore.getItemProperties(getSpellInfo()->getEffectItemType(i));
                    if (itemProperties == nullptr)
                    {
                        sLogger.failure("Spell::checkItems: Spell entry {} has unknown item id ({}) in SPELL_EFFECT_CREATE_ITEM effect", getSpellInfo()->getId(), getSpellInfo()->getEffectItemType(i));
                        return SPELL_FAILED_ERROR;
                    }
 
                    // Check if player has any free slots in the inventory
                    if (p_caster->getItemInterface()->CalculateFreeSlots(itemProperties) == 0)
                    {
                        p_caster->getItemInterface()->buildInventoryChangeError(nullptr, nullptr, INV_ERR_INVENTORY_FULL);
                        return SPELL_FAILED_DONT_REPORT;
                    }
                    
                    // Check other limitations
                    const auto itemErrorMessage = p_caster->getItemInterface()->CanReceiveItem(itemProperties, 1);
                    if (itemErrorMessage != INV_ERR_OK)
                    {
                        p_caster->getItemInterface()->buildInventoryChangeError(nullptr, nullptr, itemErrorMessage, getSpellInfo()->getEffectItemType(i));
                        return SPELL_FAILED_DONT_REPORT;
                    }
                } break;
            case SPELL_EFFECT_ENCHANT_ITEM:
            {
                // Check only for vellums here, normal checks are done in the next case
                if (getSpellInfo()->getEffectItemType(i) != 0 && m_targets.getItemTargetGuid() != 0 && vellumTarget)
                {
                    // Player can only enchant their own vellums
                    if (m_targets.isTradeItem())
                        return SPELL_FAILED_NOT_TRADEABLE;
                    // Scrolls (enchanted vellums) cannot be enchanted into another vellum (duping)
                    if (scrollItem)
                        return SPELL_FAILED_BAD_TARGETS;
 
                    const auto vellumItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                    if (vellumItem == nullptr)
                        return SPELL_FAILED_ITEM_NOT_FOUND;
                    // Check if vellum is appropriate target for the enchant
                    if (getSpellInfo()->getBaseLevel() > vellumItem->getItemProperties()->ItemLevel)
                        return SPELL_FAILED_LOWLEVEL;
 
                    const auto itemProperties = sMySQLStore.getItemProperties(getSpellInfo()->getEffectItemType(i));
                    if (itemProperties == nullptr)
                    {
                        sLogger.failure("Spell::checkItems: Spell entry {} has unknown item id ({}) in SPELL_EFFECT_ENCHANT_ITEM effect", getSpellInfo()->getId(), getSpellInfo()->getEffectItemType(i));
                        return SPELL_FAILED_ERROR;
                    }
 
                    // Check if player has any free slots in the inventory
                    if (p_caster->getItemInterface()->CalculateFreeSlots(itemProperties) == 0)
                    {
                        p_caster->getItemInterface()->buildInventoryChangeError(nullptr, nullptr, INV_ERR_INVENTORY_FULL);
                        return SPELL_FAILED_DONT_REPORT;
                    }
 
                    // Check other limitations
                    const auto itemErrorMessage = p_caster->getItemInterface()->CanReceiveItem(itemProperties, 1);
                    if (itemErrorMessage != INV_ERR_OK)
                    {
                        p_caster->getItemInterface()->buildInventoryChangeError(nullptr, nullptr, itemErrorMessage, getSpellInfo()->getEffectItemType(i));
                        return SPELL_FAILED_DONT_REPORT;
                    }
                }
#if VERSION_STRING >= WotLK
            }
            [[fallthrough]];
            case SPELL_EFFECT_ADD_SOCKET:
            {
#endif
                if (m_targets.getItemTargetGuid() == 0)
                    return SPELL_FAILED_ITEM_NOT_FOUND;
 
                Item* targetItem = nullptr;
                if (m_targets.isTradeItem())
                {
                    if (p_caster->getTradeTarget() != nullptr)
                        targetItem = p_caster->getTradeTarget()->getTradeData()->getTradeItem(TradeSlots(m_targets.getItemTargetGuid()));
                }
                else
                {
                    targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                }
 
                if (targetItem == nullptr)
                    return SPELL_FAILED_ITEM_NOT_FOUND;
 
                // Check if the item's level is high enough for the enchantment
                if (targetItem->getItemProperties()->ItemLevel < getSpellInfo()->getBaseLevel())
                    return SPELL_FAILED_LOWLEVEL;
 
                auto hasOnUseEffect = false;
                const auto itemProperties = targetItem->getItemProperties();
                for (const auto& spell : itemProperties->Spells)
                {
                    if (spell.Id == 0)
                        continue;
                    if (spell.Trigger == USE || spell.Trigger == APPLY_AURA_ON_PICKUP)
                    {
                        hasOnUseEffect = true;
                        break;
                    }
                }
 
                const auto enchantEntry = sSpellItemEnchantmentStore.lookupEntry(static_cast<uint32_t>(getSpellInfo()->getEffectMiscValue(i)));
                if (enchantEntry == nullptr)
                {
                    sLogger.failure("Spell::checkItems: Spell entry {} has no valid enchantment ({})", getSpellInfo()->getId(), getSpellInfo()->getEffectMiscValue(i));
                    return SPELL_FAILED_ERROR;
                }
 
                // Loop through enchantment's types
                for (const auto& type : enchantEntry->type)
                {
                    switch (type)
                    {
                        case ITEM_ENCHANTMENT_TYPE_USE_SPELL:
                            // Check if the item already has a 'on use' enchantment
                            if (hasOnUseEffect)
                            {
#if VERSION_STRING < WotLK
                                return SPELL_FAILED_BAD_TARGETS;
#else
                                return SPELL_FAILED_ON_USE_ENCHANT;
#endif
                            }
                            break;
#if VERSION_STRING >= WotLK
                        case ITEM_ENCHANTMENT_TYPE_PRISMATIC_SOCKET:
                            // Check if the item already has a prismatic gem slot enchanted
                            if (targetItem->getEnchantmentId(PRISMATIC_ENCHANTMENT_SLOT) != 0)
                                return SPELL_FAILED_ITEM_ALREADY_ENCHANTED;
 
                            // or if the item already has the maximum amount of socket slots
                            if (targetItem->getSocketSlotCount() >= MAX_ITEM_PROTO_SOCKETS)
                                return SPELL_FAILED_MAX_SOCKETS;
                            break;
#endif
                        default:
                            break;
                    }
                }
 
                // Check item owner in cases where enchantment makes item soulbound
                if (targetItem->getOwner() != p_caster)
                {
                    if (enchantEntry->EnchantGroups & 0x01) // Makes item soulbound
                        return SPELL_FAILED_NOT_TRADEABLE;
                }
                break;
            }
            case SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY:
            {
                if (m_targets.getItemTargetGuid() == 0)
                    return SPELL_FAILED_ITEM_NOT_FOUND;
 
                Item const* targetItem = nullptr;
                if (m_targets.isTradeItem())
                {
                    if (p_caster->getTradeTarget() != nullptr)
                        targetItem = p_caster->getTradeTarget()->getTradeData()->getTradeItem(TradeSlots(m_targets.getItemTargetGuid()));
                }
                else
                {
                    targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                }
 
                if (targetItem == nullptr)
                    return SPELL_FAILED_ITEM_NOT_FOUND;
 
                const auto enchantmentEntry = sSpellItemEnchantmentStore.lookupEntry(static_cast<uint32_t>(getSpellInfo()->getEffectMiscValue(i)));
                if (enchantmentEntry == nullptr)
                {
                    sLogger.failure("Spell::checkItems: Spell entry {} has no valid enchantment ({})", getSpellInfo()->getId(), getSpellInfo()->getEffectMiscValue(i));
                    return SPELL_FAILED_ERROR;
                }
 
                // Check item owner in cases where enchantment makes item soulbound
                if (targetItem->getOwner() != p_caster)
                {
                    if (enchantmentEntry->EnchantGroups & 0x01) // Makes item soulbound
                        return SPELL_FAILED_NOT_TRADEABLE;
                }
                break;
            }
            case SPELL_EFFECT_DISENCHANT:
            {
                if (m_targets.getItemTargetGuid() == 0)
                    return SPELL_FAILED_ITEM_GONE;
                // Check if the item target is in a trade window
                if (m_targets.isTradeItem())
                    return SPELL_FAILED_NOT_TRADEABLE;
 
                const auto targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                if (targetItem == nullptr)
                    return SPELL_FAILED_ITEM_GONE;
 
                const auto itemProperties = targetItem->getItemProperties();
                // Only armor and weapon items can be disenchanted
                if (itemProperties->Class != ITEM_CLASS_ARMOR && itemProperties->Class != ITEM_CLASS_WEAPON)
                    return SPELL_FAILED_CANT_BE_DISENCHANTED;
                // Only items with uncommon, rare and epic quality can be disenchanted
                if (itemProperties->Quality > ITEM_QUALITY_EPIC_PURPLE || itemProperties->Quality < ITEM_QUALITY_UNCOMMON_GREEN)
                    return SPELL_FAILED_CANT_BE_DISENCHANTED;
                // Some items are not disenchantable
                if (itemProperties->DisenchantReqSkill <= 0)
                    return SPELL_FAILED_CANT_BE_DISENCHANTED;
#if VERSION_STRING >= TBC
                // As of patch 2.0.1 disenchanting an item requires minimum skill level
                if (static_cast<uint32_t>(itemProperties->DisenchantReqSkill) > p_caster->getSkillLineCurrent(SKILL_ENCHANTING))
                    return SPELL_FAILED_CANT_BE_DISENCHANTED_SKILL;
#endif
                // TODO: check does the item even have disenchant loot
                break;
            }
#if VERSION_STRING >= TBC
            case SPELL_EFFECT_PROSPECTING:
            {
                if (m_targets.getItemTargetGuid() == 0)
                    return SPELL_FAILED_ITEM_GONE;
                // Check if the item target is in a trade window
                if (m_targets.isTradeItem())
                    return SPELL_FAILED_NOT_TRADEABLE;
 
                const auto targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                if (targetItem == nullptr)
                    return SPELL_FAILED_ITEM_GONE;
 
                const auto itemProperties = targetItem->getItemProperties();
                // Check if the item is prospectable
                if (!(itemProperties->Flags & ITEM_FLAG_PROSPECTABLE))
                    return SPELL_FAILED_CANT_BE_PROSPECTED;
                // Check if player has enough skill in Jewelcrafting
                if (itemProperties->RequiredSkillRank > p_caster->getSkillLineCurrent(SKILL_JEWELCRAFTING))
                {
                    *parameter1 = itemProperties->RequiredSkill;
                    *parameter2 = itemProperties->RequiredSkillRank;
                    return SPELL_FAILED_MIN_SKILL;
                }
                // Check if player has enough ores for prospecting
                if (!p_caster->hasItem(targetItem->getEntry(), 5))
                {
                    *parameter1 = targetItem->getEntry();
                    *parameter2 = 5;
#if VERSION_STRING == TBC
                    return SPELL_FAILED_PROSPECT_NEED_MORE;
#else
                    return SPELL_FAILED_NEED_MORE_ITEMS;
#endif
                }
 
                // TODO: check does the item even have prospecting loot
                break;
            }
#endif
#if VERSION_STRING >= WotLK
            case SPELL_EFFECT_MILLING:
            {
                if (m_targets.getItemTargetGuid() == 0)
                    return SPELL_FAILED_ITEM_GONE;
                // Check if the item target is in a trade window
                if (m_targets.isTradeItem())
                    return SPELL_FAILED_NOT_TRADEABLE;
 
                const auto targetItem = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
                if (targetItem == nullptr)
                    return SPELL_FAILED_ITEM_GONE;
 
                const auto itemProperties = targetItem->getItemProperties();
                // Check if the item is millable
                if (!(itemProperties->Flags & ITEM_FLAG_MILLABLE))
                    return SPELL_FAILED_CANT_BE_MILLED;
                // Check if player has enough skill in Inscription
                if (itemProperties->RequiredSkillRank > p_caster->getSkillLineCurrent(SKILL_INSCRIPTION))
                {
                    *parameter1 = itemProperties->RequiredSkill;
                    *parameter2 = itemProperties->RequiredSkillRank;
                    return SPELL_FAILED_MIN_SKILL;
                }
                if (!p_caster->hasItem(targetItem->getEntry(), 5))
                {
                    *parameter1 = targetItem->getEntry();
                    *parameter2 = 5;
                    return SPELL_FAILED_NEED_MORE_ITEMS;
                }
 
                // TODO: check does the item even have milling loot
                break;
            }
#endif
            case SPELL_EFFECT_WEAPON_DAMAGE:
            case SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL:
            {
                // Check if spell is not ranged type
                if (getSpellInfo()->getDmgClass() != SPELL_DMG_TYPE_RANGED)
                    break;
 
                const auto rangedWeapon = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
                if (rangedWeapon == nullptr || !rangedWeapon->isWeapon())
                    return SPELL_FAILED_EQUIPPED_ITEM;
                // Check if the item has any durability left
                if (rangedWeapon->getMaxDurability() > 0 && rangedWeapon->getDurability() == 0)
                    return SPELL_FAILED_EQUIPPED_ITEM;
 
#if VERSION_STRING <= WotLK
                // Check for ammunitation
                switch (rangedWeapon->getItemProperties()->SubClass)
                {
                    case ITEM_SUBCLASS_WEAPON_THROWN:
                        // In classic throwing weapons use stack count
                        // In TBC throwing weapons use durability
                        // In Wotlk+ throwing weapons use neither
#if VERSION_STRING == Classic
                        if (p_caster->getItemInterface()->GetItemCount(rangedWeapon->getEntry()) == 0)
                            return SPELL_FAILED_NO_AMMO;
#elif VERSION_STRING == TBC
                        if (rangedWeapon->getDurability() == 0)
                            return SPELL_FAILED_NO_AMMO;
#endif
                        break;
                    // Check ammo for ranged weapons
                    case ITEM_SUBCLASS_WEAPON_BOW:
                    case ITEM_SUBCLASS_WEAPON_GUN:
                    case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                    {
                        // Thori'dal, the Stars' Fury has a dummy aura which makes it generate magical arrows
                        // iirc the only item with this kind of effect?
                        if (p_caster->m_requiresNoAmmo)
                            break;
                        const auto ammoId = p_caster->getAmmoId();
                        if (ammoId == 0)
                            return SPELL_FAILED_NEED_AMMO;
 
                        const auto ammoProperties = sMySQLStore.getItemProperties(ammoId);
                        if (ammoProperties == nullptr)
                            return SPELL_FAILED_NEED_AMMO;
                        if (ammoProperties->Class != ITEM_CLASS_PROJECTILE)
                            return SPELL_FAILED_NEED_AMMO;
                        if (ammoProperties->RequiredLevel > p_caster->getLevel())
                            return SPELL_FAILED_NEED_AMMO;
 
                        // Check for correct projectile type
                        if (rangedWeapon->getItemProperties()->SubClass == ITEM_SUBCLASS_WEAPON_GUN)
                        {
                            if (ammoProperties->SubClass != ITEM_SUBCLASS_PROJECTILE_BULLET)
                                return SPELL_FAILED_NEED_AMMO;
                        }
                        else
                        {
                            if (ammoProperties->SubClass != ITEM_SUBCLASS_PROJECTILE_ARROW)
                                return SPELL_FAILED_NEED_AMMO;
                        }
 
                        // Check if player is out of ammos
                        if (!p_caster->hasItem(ammoId))
                        {
                            p_caster->setAmmoId(0);
                            return SPELL_FAILED_NO_AMMO;
                        }
                    } break;
                    default:
                        break;
                }
#endif
                break;
            }
            default:
                break;
        }
    }
 
    return SPELL_CAST_SUCCESS;
}

Here is the caller graph for this function:

◆ checkPower()

SpellCastResult Spell::checkPower ( )

Definition at line 3250 of file Spell.cpp.

{
    if (m_powerCost == 0)
        return SPELL_CAST_SUCCESS;
 
    if (p_caster != nullptr && p_caster->m_cheats.hasPowerCheat)
        return SPELL_CAST_SUCCESS;
 
    // Check if caster has enough health points if health is used for power
    if (getSpellInfo()->getPowerType() == POWER_TYPE_HEALTH)
    {
        if (u_caster != nullptr)
        {
            if (u_caster->getHealth() <= m_powerCost)
                return SPELL_FAILED_FIZZLE;
        }
 
        // No need to do any further checking
        return SPELL_CAST_SUCCESS;
    }
 
    // Invalid power types
    if (!getSpellInfo()->hasValidPowerType())
    {
        sLogger.failure("Spell::checkPower : Unknown power type {} for spell id {}", getSpellInfo()->getPowerType(), getSpellInfo()->getId());
        return SPELL_FAILED_ERROR;
    }
 
#if VERSION_STRING >= WotLK
    // Check runes for spells which have runes in power type
    if (getSpellInfo()->getPowerType() == POWER_TYPE_RUNES)
    {
        const auto runeResult = checkRunes(false);
        if (runeResult != SPELL_CAST_SUCCESS)
            return runeResult;
    }
#endif
 
    // Normal case
    if (u_caster != nullptr && u_caster->getPower(getSpellInfo()->getPowerType()) < m_powerCost)
        return SPELL_FAILED_NO_POWER;
 
    return SPELL_CAST_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkRange()

SpellCastResult Spell::checkRange ( const bool secondCheck )

private

\ todo: Needs retesting after movement system has been rewritten

Definition at line 4296 of file Spell.cpp.

{
    const auto rangeEntry = sSpellRangeStore.lookupEntry(getSpellInfo()->getRangeIndex());
    if (rangeEntry == nullptr)
        return SPELL_CAST_SUCCESS;
 
    // Players can activate "on next attack" abilities before being at melee range
    if (!secondCheck && getSpellInfo()->isOnNextMeleeAttack())
        return SPELL_CAST_SUCCESS;
 
    auto targetUnit = m_caster->getWorldMapUnit(m_targets.getUnitTargetGuid());
 
    // Self cast spells don't need range check
    if (getSpellInfo()->getRangeIndex() == 1 || targetUnit == m_caster)
        return SPELL_CAST_SUCCESS;
 
    if (u_caster != nullptr)
    {
        // If pet is the effect target, check range to pet
        for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (getSpellInfo()->getEffectImplicitTargetA(i) != EFF_TARGET_PET)
                continue;
 
            if (u_caster->getPet() != nullptr)
            {
                targetUnit = u_caster->getPet();
                break;
            }
        }
    }
 
    float_t minRange = 0.0f, maxRange = 0.0f, rangeMod = 0.0f;
    if (rangeEntry->range_type & SPELL_RANGE_TYPE_MASK_MELEE)
    {
        if (u_caster != nullptr)
        {
            // Use caster's combat reach if target is not found
            const float_t combatReach = targetUnit != nullptr ? targetUnit->getCombatReach() : u_caster->getCombatReach();
            // Caster's combat reach + 1.333... + target's (or caster's again) combat reach
            rangeMod = std::max(5.0f, u_caster->getCombatReach() + (4.0f / 3.0f) + combatReach);
        }
    }
    else
    {
        if (u_caster != nullptr && rangeEntry->range_type & SPELL_RANGE_TYPE_MASK_RANGED)
        {
            // Use caster's combat reach if target is not found
            const float_t combatReach = targetUnit != nullptr ? targetUnit->getCombatReach() : u_caster->getCombatReach();
            // Caster's combat reach + 1.33f + target's (or caster's again) combat reach
            minRange = std::max(5.0f, u_caster->getCombatReach() + (4.0f / 3.0f) + combatReach);
        }
 
        // Get minimum range
#if VERSION_STRING < WotLK
        minRange += rangeEntry->minRange;
#else
        if (targetUnit == nullptr)
            minRange += rangeEntry->minRange;
        else
            minRange += m_caster->isFriendlyTo(targetUnit) ? rangeEntry->minRangeFriendly : rangeEntry->minRange;
#endif
 
        // Get maximum range
#if VERSION_STRING < WotLK
        maxRange = rangeEntry->maxRange;
#else
        if (targetUnit == nullptr)
            maxRange = rangeEntry->maxRange;
        else
            maxRange = m_caster->isFriendlyTo(targetUnit) ? rangeEntry->maxRangeFriendly : rangeEntry->maxRange;
#endif
 
        // Player, creature or corpse target
        if (u_caster != nullptr && (targetUnit != nullptr || m_targets.getTargetMask() & (TARGET_FLAG_CORPSE | TARGET_FLAG_CORPSE2)))
        {
            const float_t combatReach = targetUnit != nullptr ? targetUnit->getCombatReach() : u_caster->getCombatReach();
            rangeMod = u_caster->getCombatReach() + combatReach;
            if (minRange > 0.0f && !(rangeEntry->range_type & SPELL_RANGE_TYPE_MASK_RANGED))
                minRange += rangeMod;
        }
    }
 
    // Spell leeway - Client increases spell's range if the caster is moving (walking is not accounted)
    ///\ todo: Needs retesting after movement system has been rewritten
    if (u_caster != nullptr && u_caster->hasUnitMovementFlag(MOVEFLAG_MOVING_MASK) && !u_caster->hasUnitMovementFlag(MOVEFLAG_WALK))
    {
        // Leeway mechanic also depends on target - target also needs to be moving (again, walking is not accounted)
        if (targetUnit != nullptr && targetUnit->hasUnitMovementFlag(MOVEFLAG_MOVING_MASK) && !targetUnit->hasUnitMovementFlag(MOVEFLAG_WALK)
            && (rangeEntry->range_type & SPELL_RANGE_TYPE_MASK_MELEE || targetUnit->isPlayer()))
            rangeMod += 8.0f / 3.0f; // 2.6666... yards
    }
 
    // Add range from ranged weapon to max range
    if (p_caster != nullptr && getSpellInfo()->getAttributes() & ATTRIBUTES_RANGED)
    {
        const auto rangedWeapon = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
        if (rangedWeapon != nullptr)
            maxRange *= rangedWeapon->getItemProperties()->Range * 0.01f;
    }
 
    // Add 5 yards to range check for spell landing because some spells have a delay before landing
    rangeMod += secondCheck ? (m_caster->isPlayer() ? 6.25f : 2.25f) : (m_caster->isPlayer() ? 1.25f : 0.0f);
 
    // Apply spell modifiers to range
    if (u_caster != nullptr)
        u_caster->applySpellModifiers(SPELLMOD_RANGE, &maxRange, getSpellInfo(), this);
 
    maxRange += rangeMod;
 
    // Square values for range check
    minRange *= minRange;
    maxRange *= maxRange;
 
    if (targetUnit != nullptr && targetUnit != m_caster)
    {
        const float_t distance = m_caster->getDistanceSq(targetUnit);
        if (minRange > 0.0f && distance < minRange)
            return SPELL_FAILED_TOO_CLOSE;
        if (distance > maxRange)
            return SPELL_FAILED_OUT_OF_RANGE;
    }
 
    // AoE spells on targeted location
    if (m_targets.hasDestination())
    {
        const float_t distance = m_caster->getDistanceSq(m_targets.getDestination());
        if (minRange > 0.0f && distance < minRange)
            return SPELL_FAILED_TOO_CLOSE;
        if (distance > maxRange)
            return SPELL_FAILED_OUT_OF_RANGE;
    }
 
    return SPELL_CAST_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkRunes()

SpellCastResult Spell::checkRunes ( bool takeRunes )

private

Definition at line 4433 of file Spell.cpp.

{
    // Check only for players and for spells which have rune cost
    if (getSpellInfo()->getRuneCostID() > 0 && p_caster != nullptr)
    {
        // Classes other than Death Knights should not cast spells which use runes
        if (!p_caster->isClassDeathKnight())
            return SPELL_FAILED_NO_POWER;
 
        const auto spellRuneCost = sSpellRuneCostStore.lookupEntry(getSpellInfo()->getRuneCostID());
        if (spellRuneCost != nullptr && (spellRuneCost->bloodRuneCost > 0 || spellRuneCost->frostRuneCost > 0 || spellRuneCost->unholyRuneCost > 0))
        {
            uint32_t runeCost[3];
            runeCost[RUNE_BLOOD] = spellRuneCost->bloodRuneCost;
            runeCost[RUNE_FROST] = spellRuneCost->frostRuneCost;
            runeCost[RUNE_UNHOLY] = spellRuneCost->unholyRuneCost;
 
            // Apply modifers
            for (uint8_t i = 0; i < RUNE_DEATH; ++i)
            {
                p_caster->applySpellModifiers(SPELLMOD_COST, &runeCost[i], getSpellInfo(), this);
            }
 
            if (const auto dkPlayer = dynamic_cast<DeathKnight*>(p_caster))
            {
                // Get available runes and subtract them from the power cost
                // If the outcome is over zero, it means player doesn't have enough runes available
                auto missingRunes = dkPlayer->HasRunes(RUNE_BLOOD, runeCost[RUNE_BLOOD]) + dkPlayer->HasRunes(RUNE_FROST, runeCost[RUNE_FROST]) + dkPlayer->HasRunes(RUNE_UNHOLY, runeCost[RUNE_UNHOLY]);
                // If there aren't enough normal runes available, try death runes
                if (missingRunes > 0 && dkPlayer->HasRunes(RUNE_DEATH, missingRunes) > 0)
                    return SPELL_FAILED_NO_POWER;
 
                if (takeRunes)
                {
                    missingRunes = dkPlayer->TakeRunes(RUNE_BLOOD, runeCost[RUNE_BLOOD]) + dkPlayer->TakeRunes(RUNE_FROST, runeCost[RUNE_FROST]) + dkPlayer->TakeRunes(RUNE_UNHOLY, runeCost[RUNE_UNHOLY]);
                    if (missingRunes > 0 && dkPlayer->TakeRunes(RUNE_DEATH, missingRunes) > 0)
                        return SPELL_FAILED_NO_POWER;
 
                    // Death knights gains some runic power when using runes
                    if (spellRuneCost->runePowerGain > 0)
                    {
                        const auto runicPowerAmount = static_cast<uint32_t>((spellRuneCost->runePowerGain + dkPlayer->getPower(POWER_TYPE_RUNIC_POWER)) * worldConfig.getFloatRate(RATE_POWER7));
                        dkPlayer->setPower(POWER_TYPE_RUNIC_POWER, runicPowerAmount);
                    }
                }
            }
        }
    }
 
    return SPELL_CAST_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkShapeshift()

SpellCastResult Spell::checkShapeshift	(	SpellInfo const *	spellInfo,
		const uint32_t	shapeshiftForm
	)		const

private

Definition at line 4486 of file Spell.cpp.

{
#if VERSION_STRING < Mop
    // No need to check requirements for talents that learn spells
    uint8_t talentRank = 0;
    const auto talentInfo = sTalentStore.lookupEntry(spellInfo->getId());
    if (talentInfo != nullptr)
    {
        for (uint8_t i = 0; i < 5; ++i)
        {
            if (talentInfo->RankID[i] != 0)
                talentRank = i + 1U;
        }
    }
 
    // This is client-side only
    if (talentRank > 0 && spellInfo->hasEffect(SPELL_EFFECT_LEARN_SPELL))
        return SPELL_CAST_SUCCESS;
 
    const uint32_t stanceMask = shapeshiftForm ? 1 << (shapeshiftForm - 1U) : 0U;
 
    // Cannot explicitly be casted in this stance/form
    if (spellInfo->getShapeshiftExclude() > 0 && spellInfo->getShapeshiftExclude() & stanceMask)
        return SPELL_FAILED_NOT_SHAPESHIFT;
 
    // Can explicitly be casted in this stance/form
    if (spellInfo->getRequiredShapeShift() > 0 && spellInfo->getRequiredShapeShift() & stanceMask)
        return SPELL_CAST_SUCCESS;
 
    auto actAsShifted = false;
    if (stanceMask > FORM_NORMAL)
    {
        auto shapeShift = sSpellShapeshiftFormStore.lookupEntry(shapeshiftForm);
        if (shapeShift == nullptr)
        {
            sLogger.failure("Spell::checkShapeshift: Caster has unknown shapeshift form {}", shapeshiftForm);
            return SPELL_CAST_SUCCESS;
        }
 
        // Check if shapeshift acts as normal form for spells
        actAsShifted = !(shapeShift->Flags & 1);
    }
 
    if (actAsShifted)
    {
        // Cannot be casted while shapeshifted
        if (spellInfo->getAttributes() & ATTRIBUTES_NOT_SHAPESHIFT)
            return SPELL_FAILED_NOT_SHAPESHIFT;
        // Needs another shapeshift form
        else if (spellInfo->getRequiredShapeShift() != 0)
            return SPELL_FAILED_ONLY_SHAPESHIFT;
    }
    else
    {
        // Check if spell even requires shapeshift
        if (!(spellInfo->getAttributesExB() & ATTRIBUTESEXB_NOT_NEED_SHAPESHIFT) && spellInfo->getRequiredShapeShift() != 0)
            return SPELL_FAILED_ONLY_SHAPESHIFT;
    }
    return SPELL_CAST_SUCCESS;
#else
    return SPELL_FAILED_ONLY_SHAPESHIFT;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateItem()

void Spell::CreateItem ( uint32_t itemId )

Creates number of items equal to a "damage" of the effect

Definition at line 2720 of file Spell.Legacy.cpp.

{
    /// Creates number of items equal to a "damage" of the effect
    if (itemId == 0 || p_caster == nullptr)
        return;
 
    p_caster->getItemInterface()->AddItemById(itemId, damage, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DetermineSkillUp() [1/3]

void Spell::DetermineSkillUp ( )

Definition at line 1599 of file Spell.Legacy.cpp.

{
    if (p_caster == nullptr)
        return;
 
    auto skill_line_ability = sSpellMgr.getFirstSkillEntryForSpell(getSpellInfo()->getId());
    if (skill_line_ability == nullptr)
        return;
 
    float chance = 0.0f;
 
    const auto skillLine = static_cast<uint16_t>(skill_line_ability->skilline);
    if (p_caster->hasSkillLine(skillLine))
    {
        uint32_t amt = p_caster->getSkillLineCurrent(skillLine, false);
        uint32_t max = p_caster->getSkillLineMax(skillLine);
        if (amt >= max)
            return;
        if (amt >= skill_line_ability->grey)   //grey
            chance = 0.0f;
        else if ((amt >= (((skill_line_ability->grey - skill_line_ability->green) / 2) + skill_line_ability->green)))          //green
            chance = 33.0f;
        else if (amt >= skill_line_ability->green)   //yellow
            chance = 66.0f;
        else //brown
            chance = 100.0f;
    }
    if (Util::checkChance(chance * worldConfig.getFloatRate(RATE_SKILLCHANCE)))
        p_caster->advanceSkillLine(skillLine, static_cast<uint16_t>(Util::float2int32(1.0f * worldConfig.getFloatRate(RATE_SKILLRATE))));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DetermineSkillUp() [2/3]

void Spell::DetermineSkillUp ( uint16_t skillid )

Definition at line 2857 of file Spell.Legacy.cpp.

{
    //This code is wrong for creating items and disenchanting.
    if (p_caster == nullptr)
        return;
 
    auto skill_line_ability = sSpellMgr.getFirstSkillEntryForSpell(getSpellInfo()->getId());
    if (skill_line_ability != nullptr && skillid == skill_line_ability->skilline && p_caster->hasSkillLine(skillid))
    {
        float chance = 0.0f;
        uint32_t amt = p_caster->getSkillLineCurrent(skillid, false);
        uint32_t max = p_caster->getSkillLineMax(skillid);
        if (amt >= max)
            return;
        if (amt >= skill_line_ability->grey)   //grey
            chance = 0.0f;
        else if ((amt >= (((skill_line_ability->grey - skill_line_ability->green) / 2) + skill_line_ability->green)))          //green
            chance = 33.0f;
        else if (amt >= skill_line_ability->green)   //yellow
            chance = 66.0f;
        else //brown
            chance = 100.0f;
 
        if (Util::checkChance(chance * worldConfig.getFloatRate(RATE_SKILLCHANCE)))
            p_caster->advanceSkillLine(skillid, static_cast<uint16_t>(Util::float2int32(1.0f * worldConfig.getFloatRate(RATE_SKILLRATE))));
    }
}

Here is the call graph for this function:

◆ DetermineSkillUp() [3/3]

void Spell::DetermineSkillUp	(	uint16_t	skillid,
		uint32_t	targetlevel,
		uint32_t	multiplicator = `1`
	)

Definition at line 2731 of file Spell.Legacy.cpp.

{
    if (p_caster == nullptr)
        return;
 
    if (p_caster->getSkillUpChance(skillid) < 0.01)
        return;//to prevent getting higher skill than max
 
    int32_t diff = p_caster->getSkillLineCurrent(skillid, false) / 5 - targetlevel;
 
    if (diff < 0)
        diff = -diff;
 
    float chance;
    if (diff <= 5)
        chance = 95.0f;
    else if (diff <= 10)
        chance = 66.0f;
    else if (diff <= 15)
        chance = 33.0f;
    else
        return;
 
    if (multiplicator == 0)
        multiplicator = 1;
 
    if (Util::checkChance((chance * worldConfig.getFloatRate(RATE_SKILLCHANCE)) * multiplicator))
    {
        p_caster->advanceSkillLine(skillid, static_cast<uint16_t>(Util::float2int32(1.0f * worldConfig.getFloatRate(RATE_SKILLRATE))));
 
        uint32_t value = p_caster->getSkillLineCurrent(skillid, true);
        uint32_t spellid = 0;
 
        // Lifeblood
        if (skillid == SKILL_HERBALISM)
        {
            switch (value)
            {
                case 75:
                {   spellid = 55428; }
                break;// Rank 1
                case 150:
                {   spellid = 55480; }
                break;// Rank 2
                case 225:
                {   spellid = 55500; }
                break;// Rank 3
                case 300:
                {   spellid = 55501; }
                break;// Rank 4
                case 375:
                {   spellid = 55502; }
                break;// Rank 5
                case 450:
                {   spellid = 55503; }
                break;// Rank 6
                case 525:
                {    spellid = 74497; }
                break;// Rank 7
            }
        }
 
        // Toughness
        else if (skillid == SKILL_MINING)
        {
            switch (value)
            {
                case 75:
                {   spellid = 53120; }
                break;// Rank 1
                case 150:
                {   spellid = 53121; }
                break;// Rank 2
                case 225:
                {   spellid = 53122; }
                break;// Rank 3
                case 300:
                {   spellid = 53123; }
                break;// Rank 4
                case 375:
                {   spellid = 53124; }
                break;// Rank 5
                case 450:
                {   spellid = 53040; }
                break;// Rank 6
                case 525:
                {    spellid = 74496; }
                break;// Rank 7
            }
        }
 
 
        // Master of Anatomy
        else if (skillid == SKILL_SKINNING)
        {
            switch (value)
            {
                case 75:
                {   spellid = 53125; }
                break;// Rank 1
                case 150:
                {   spellid = 53662; }
                break;// Rank 2
                case 225:
                {   spellid = 53663; }
                break;// Rank 3
                case 300:
                {   spellid = 53664; }
                break;// Rank 4
                case 375:
                {   spellid = 53665; }
                break;// Rank 5
                case 450:
                {   spellid = 53666; }
                break;// Rank 6
                case 525:
                {   spellid = 74495; }
                break;// Rank 7
            }
        }
 
        if (spellid != 0)
            p_caster->addSpell(spellid, skillid);
    }
}

Here is the call graph for this function:

◆ DidHit()

uint8_t Spell::DidHit	(	uint32_t	effindex,
		Unit *	target
	)

Todo:: SB@L - This mechanic resist chance is handled twice, once several lines above, then as part of resistchance here check mechanical resistance i have no idea what is the best pace for this code

Definition at line 417 of file Spell.Legacy.cpp.

{
    //note resistchance is vise versa, is full hit chance
    Unit* u_victim = target;
    if (u_victim == nullptr)
        return SPELL_DID_HIT_MISS;
 
    Player* p_victim = target->isPlayer() ? static_cast<Player*>(target) : NULL;
 
    float baseresist[3] = { 4.0f, 5.0f, 6.0f };
    int32_t lvldiff;
    float resistchance;
 
 
    /************************************************************************/
    /* Can't resist non-unit                                                */
    /************************************************************************/
    if (u_caster == nullptr)
        return SPELL_DID_HIT_SUCCESS;
 
    /************************************************************************/
    /* Can't reduce your own spells                                         */
    /************************************************************************/
    if (u_caster == u_victim)
        return SPELL_DID_HIT_SUCCESS;
 
    /************************************************************************/
    /* Check if the player target is able to deflect spells                 */
    /* Currently (3.3.5a) there is only spell doing that: Deterrence        */
    /************************************************************************/
#if VERSION_STRING >= WotLK
    if (p_victim && p_victim->hasAuraWithAuraEffect(SPELL_AURA_DEFLECT_SPELLS))
    {
        return SPELL_DID_HIT_DEFLECT;
    }
#endif
 
    // APGL End
    // MIT Start
 
    // Check if creature target is in evade mode
    if (target->isCreature() && target->isInEvadeMode())
        return SPELL_DID_HIT_EVADE;
 
    // Check if unit target is immune to this spell effect
    if (target->getSpellImmunity() != SPELL_IMMUNITY_NONE)
    {
        if (target->hasSpellImmunity(SPELL_IMMUNITY_CHARM))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_CHARMED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_CHARMED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_CONFUSE))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_DISORIENTED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_DISORIENTED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_FEAR))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_FLEEING ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_FLEEING)
                return SPELL_DID_HIT_IMMUNE;
 
            if (getSpellInfo()->getMechanicsType() == MECHANIC_HORRIFIED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_HORRIFIED)
                return SPELL_DID_HIT_IMMUNE;
 
            if (getSpellInfo()->getMechanicsType() == MECHANIC_TURNED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_TURNED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_ROOT))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_ROOTED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_ROOTED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_SILENCE))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_SILENCED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_SILENCED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_STUN))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_STUNNED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_STUNNED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_POLYMORPH))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_POLYMORPHED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_POLYMORPHED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_BANISH))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_BANISHED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_BANISHED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_SAP))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_SAPPED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_SAPPED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_FROZEN))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_FROZEN ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_FROZEN)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_SLOW))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_ENSNARED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_ENSNARED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_SLEEP))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_ASLEEP ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_ASLEEP)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_TAUNT))
        {
            if (getSpellInfo()->getEffect(effindex) == SPELL_EFFECT_ATTACK_ME ||
                getSpellInfo()->getEffectApplyAuraName(effindex) == SPELL_AURA_MOD_TAUNT)
                return SPELL_DID_HIT_IMMUNE;
        }
 
#if VERSION_STRING >= TBC
        if (target->hasSpellImmunity(SPELL_IMMUNITY_SPELL_HASTE))
        {
            if (getSpellInfo()->getEffectApplyAuraName(effindex) == SPELL_AURA_INCREASE_CASTING_TIME_PCT)
                return SPELL_DID_HIT_IMMUNE;
        }
#endif
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_INTERRUPT_CAST))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_INTERRUPTED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_INTERRUPTED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_MOD_HEALING))
        {
            if (getSpellInfo()->getEffectApplyAuraName(effindex) == SPELL_AURA_MOD_HEALING_DONE_PERCENT)
            {
                // Prevent only effects with negative value
                const auto val = getSpellInfo()->calculateEffectValue(effindex);
                if (val < 0)
                    return SPELL_DID_HIT_IMMUNE;
            }
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_TOTAL_STATS))
        {
            if (getSpellInfo()->getEffectApplyAuraName(effindex) == SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE)
            {
                // Prevent only effects with negative value
                const auto val = getSpellInfo()->calculateEffectValue(effindex);
                if (val < 0)
                    return SPELL_DID_HIT_IMMUNE;
            }
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_KNOCKBACK))
        {
            if (getSpellInfo()->getEffect(effindex) == SPELL_EFFECT_KNOCK_BACK
#if VERSION_STRING >= TBC
                || getSpellInfo()->getEffect(effindex) == SPELL_EFFECT_KNOCK_BACK_DEST
#endif
                )
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_DISARM))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_DISARMED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_DISARMED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_INCAPACITATE))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_INCAPACIPATED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_INCAPACIPATED)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_BLEED))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_BLEEDING ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_BLEEDING)
                return SPELL_DID_HIT_IMMUNE;
        }
 
        if (target->hasSpellImmunity(SPELL_IMMUNITY_SHACKLE))
        {
            if (getSpellInfo()->getMechanicsType() == MECHANIC_SHACKLED ||
                getSpellInfo()->getEffectMechanic(effindex) == MECHANIC_SHACKLED)
                return SPELL_DID_HIT_IMMUNE;
        }
    }
 
    // Check if target can reflect this spell
    if (m_canBeReflected)
    {
        auto isReflected = false;
        for (const auto& reflectAura : u_victim->m_reflectSpellSchool)
        {
            if (reflectAura->school != -1 && reflectAura->school != getSpellInfo()->getFirstSchoolFromSchoolMask())
                continue;
 
            if (Util::checkChance(static_cast<float_t>(reflectAura->chance)))
            {
                //the god blessed special case : mage - Frost Warding = is an augmentation to frost warding
                if (reflectAura->spellId != 0 && !u_victim->hasAurasWithId(reflectAura->spellId))
                    continue;
 
                if (reflectAura->infront)
                {
                    if (m_caster->isInFront(u_victim))
                        isReflected = true;
                }
                else
                {
                    isReflected = true;
                }
 
                if (reflectAura->charges > 0)
                {
                    reflectAura->charges--;
                    if (reflectAura->charges <= 0)
                    {
                        // should delete + erase RSS too, if unit hasn't such an aura...
                        if (!u_victim->hasAurasWithId(reflectAura->spellId))
                        {
                            // ...do it manually
                            u_victim->m_reflectSpellSchool.remove(reflectAura);
                        }
                        else
                        {
                            u_victim->removeAllAurasById(reflectAura->spellId);
                        }
                    }
                }
 
                break;
            }
        }
 
        if (isReflected)
            return SPELL_DID_HIT_REFLECT;
    }
 
    // MIT End
    // APGL Start
 
    /************************************************************************/
    /* Check if the target is immune to this spell school                   */
    /* Unless the spell would actually dispel invulnerabilities             */
    /************************************************************************/
    int dispelMechanic = getSpellInfo()->getEffect(0) == SPELL_EFFECT_DISPEL_MECHANIC && getSpellInfo()->getEffectMiscValue(0) == MECHANIC_INVULNERABLE;
    if (u_victim->m_schoolImmunityList[getSpellInfo()->getFirstSchoolFromSchoolMask()] && !dispelMechanic)
        return SPELL_DID_HIT_IMMUNE;
 
    /* Check if player target has god mode */
    if (p_victim && p_victim->m_cheats.hasGodModeCheat)
    {
        return SPELL_DID_HIT_IMMUNE;
    }
 
    /*************************************************************************/
    /* Check if the target is immune to this mechanic                        */
    /*************************************************************************/
    if (getSpellInfo()->getMechanicsType() < TOTAL_SPELL_MECHANICS && u_victim->m_mechanicsDispels[getSpellInfo()->getMechanicsType()])
 
    {
        // Immune - IF, and ONLY IF, there is no damage component!
        bool no_damage_component = true;
        for (uint8_t x = 0; x <= 2; x++)
        {
            if (getSpellInfo()->getEffect(x) == SPELL_EFFECT_SCHOOL_DAMAGE
                || getSpellInfo()->getEffect(x) == SPELL_EFFECT_WEAPON_PERCENT_DAMAGE
                || getSpellInfo()->getEffect(x) == SPELL_EFFECT_WEAPON_DAMAGE
                || getSpellInfo()->getEffect(x) == SPELL_EFFECT_WEAPON_DAMAGE_NOSCHOOL
                || getSpellInfo()->getEffect(x) == SPELL_EFFECT_DUMMY
                || (getSpellInfo()->getEffect(x) == SPELL_EFFECT_APPLY_AURA &&
                (getSpellInfo()->getEffectApplyAuraName(x) == SPELL_AURA_PERIODIC_DAMAGE
                ))
                )
            {
                no_damage_component = false;
                break;
            }
        }
        if (no_damage_component)
            return SPELL_DID_HIT_IMMUNE; // Moved here from Spell::CanCast
    }
 
    /************************************************************************/
    /* Check if the target has a % resistance to this mechanic              */
    /************************************************************************/
    if (getSpellInfo()->getMechanicsType() < TOTAL_SPELL_MECHANICS)
    {
        float res = u_victim->m_mechanicsResistancesPct[getSpellInfo()->getMechanicsType()];
        if (Util::checkChance(res))
            return SPELL_DID_HIT_RESIST;
    }
 
    /************************************************************************/
    /* Check if the spell is a melee attack and if it was missed/parried    */
    /************************************************************************/
    uint32_t melee_test_result;
    if (getSpellInfo()->getDmgClass() == SPELL_DMG_TYPE_MELEE || getSpellInfo()->getDmgClass() == SPELL_DMG_TYPE_RANGED)
    {
        uint32_t _type;
        if (GetType() == SPELL_DMG_TYPE_RANGED)
            _type = RANGED;
        else
        {
            if (hasAttributeExC(ATTRIBUTESEXC_REQUIRES_OFFHAND_WEAPON))
                _type = OFFHAND;
            else
                _type = MELEE;
        }
 
        melee_test_result = u_caster->getSpellDidHitResult(u_victim, _type, this);
        if (melee_test_result != SPELL_DID_HIT_SUCCESS)
            return (uint8_t)melee_test_result;
    }
 
    /************************************************************************/
    /* Check if the spell is resisted.                                      */
    /************************************************************************/
    if (getSpellInfo()->getFirstSchoolFromSchoolMask() == SCHOOL_NORMAL  && getSpellInfo()->getMechanicsType() == MECHANIC_NONE)
        return SPELL_DID_HIT_SUCCESS;
 
    bool pvp = (p_caster && p_victim);
 
    if (pvp)
        lvldiff = p_victim->getLevel() - p_caster->getLevel();
    else
        lvldiff = u_victim->getLevel() - u_caster->getLevel();
    if (lvldiff < 0)
    {
        resistchance = baseresist[0] + lvldiff;
    }
    else
    {
        if (lvldiff < 3)
        {
            resistchance = baseresist[lvldiff];
        }
        else
        {
            if (pvp)
                resistchance = baseresist[2] + (((float)lvldiff - 2.0f) * 7.0f);
            else
                resistchance = baseresist[2] + (((float)lvldiff - 2.0f) * 11.0f);
        }
    }
    ///\todo SB@L - This mechanic resist chance is handled twice, once several lines above, then as part of resistchance here check mechanical resistance i have no idea what is the best pace for this code
    if (getSpellInfo()->getMechanicsType() < TOTAL_SPELL_MECHANICS)
    {
        resistchance += u_victim->m_mechanicsResistancesPct[getSpellInfo()->getMechanicsType()];
    }
    //rating bonus
    if (p_caster != nullptr)
    {
        resistchance -= p_caster->calcRating(CR_HIT_SPELL);
        resistchance -= p_caster->getHitFromSpell();
    }
 
    // school hit resistance: check all schools and take the minimal
    if (p_victim != nullptr && getSpellInfo()->getSchoolMask() > 0)
    {
        int32_t min = 100;
        for (uint8_t i = 0; i < TOTAL_SPELL_SCHOOLS; i++)
        {
            if (getSpellInfo()->getSchoolMask() & (1 << i) && min > p_victim->m_resistHitSpell[i])
                min = p_victim->m_resistHitSpell[i];
        }
        resistchance += min;
    }
 
    if (getSpellInfo()->getEffect(static_cast<uint8_t>(effindex)) == SPELL_EFFECT_DISPEL)
    {
        u_caster->applySpellModifiers(SPELLMOD_RESIST_DISPEL, &resistchance, getSpellInfo(), this);
    }
 
    float hitchance = 0;
    u_caster->applySpellModifiers(SPELLMOD_HITCHANCE, &hitchance, getSpellInfo(), this);
    resistchance -= hitchance;
 
    if (hasAttribute(ATTRIBUTES_IGNORE_INVULNERABILITY))
        resistchance = 0.0f;
 
    if (resistchance >= 100.0f)
        return SPELL_DID_HIT_RESIST;
    else
    {
        uint8_t res;
        if (resistchance <= 1.0) //resist chance >=1
            res = (Util::checkChance(1.0f) ? uint8_t(SPELL_DID_HIT_RESIST) : uint8_t(SPELL_DID_HIT_SUCCESS));
        else
            res = (Util::checkChance(resistchance) ? uint8_t(SPELL_DID_HIT_RESIST) : uint8_t(SPELL_DID_HIT_SUCCESS));
 
        if (res == SPELL_DID_HIT_SUCCESS)  // proc handling. mb should be moved outside this function
        {
            // u_caster->HandleProc(PROC_ON_SPELL_LAND,target,GetProto());
        }
 
        return res;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DoAfterHandleEffect()

void Spell::DoAfterHandleEffect	(	Unit *	target,
		uint32_t	i
	)

protectedvirtual

Reimplemented in RuneStrileSpell, BloodStrikeSpell, HeartStrikeSpell, DispersionSpell, FirestarterTalent, and MissileBarrage.

Definition at line 2670 of file Spell.Legacy.cpp.

2671{

2672}

Here is the caller graph for this function:

◆ DoCalculateEffect()

int32_t Spell::DoCalculateEffect	(	uint32_t	i,
		Unit *	target,
		int32_t	value
	)

protectedvirtual

Reimplemented in BloodPlagueSpell, IcyTouchSpell, FrostFeverSpell, VampiricBloodSpell, InnervateSpell, BloodBoilSpell, BloodwormSpell, and BloodStrikeSpell.

Definition at line 2021 of file Spell.Legacy.cpp.

{
    //1 switch: checking spell id. If the spell is not handled in the first block,
    //2nd block of checks is reached. bool handled is initialized as true and set to false in the default: case of each switch.
    bool handled = true;
 
    switch (getSpellInfo()->getId())
    {
        // SPELL_HASH_STEADY_SHOT:
        case 34120:
        case 49051:
        case 49052:
        case 56641:
        case 65867:
        {
            if (u_caster != nullptr && i == 0)
            {
                if (p_caster != nullptr)
                {
                    Item* it;
                    it = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
                    if (it)
                    {
                        float weapondmg = Util::getRandomFloat(1) * (it->getItemProperties()->Damage[0].Max - it->getItemProperties()->Damage[0].Min) + it->getItemProperties()->Damage[0].Min;
                        value += Util::float2int32(getSpellInfo()->getEffectBasePoints(0) + weapondmg / (it->getItemProperties()->Delay / 1000.0f) * 2.8f);
                    }
                }
                if (target && target->isDazed())
                    value += getSpellInfo()->getEffectBasePoints(1);
                value += (uint32_t)(u_caster->getCalculatedRangedAttackPower() * 0.1);
            }
        } break;
 
        // SPELL_HASH_REND:
        case 772:
        case 6546:
        case 6547:
        case 6548:
        case 11572:
        case 11573:
        case 11574:
        case 11977:
        case 12054:
        case 13318:
        case 13443:
        case 13445:
        case 13738:
        case 14087:
        case 14118:
        case 16393:
        case 16403:
        case 16406:
        case 16509:
        case 17153:
        case 17504:
        case 18075:
        case 18078:
        case 18106:
        case 18200:
        case 18202:
        case 21949:
        case 25208:
        case 29574:
        case 29578:
        case 36965:
        case 36991:
        case 37662:
        case 43246:
        case 43931:
        case 46845:
        case 47465:
        case 48880:
        case 53317:
        case 54703:
        case 54708:
        case 59239:
        case 59343:
        case 59691:
        {
            if (p_caster != nullptr)
            {
                Item* it;
                it = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                if (it)
                {
                    if (it->getItemProperties()->Class == 2)
                    {
                        float avgwepdmg = (it->getItemProperties()->Damage[0].Min + it->getItemProperties()->Damage[0].Max) * 0.5f;
                        float wepspd = (it->getItemProperties()->Delay * 0.001f);
                        int32_t dmg = Util::float2int32((avgwepdmg)+p_caster->getCalculatedAttackPower() / 14 * wepspd);
 
                        if (target && target->getHealthPct() > 75)
                        {
                            dmg = Util::float2int32(dmg + dmg * 0.35f);
                        }
 
                        value += dmg / 5;
                    }
                }
            }
        } break;
 
        // SPELL_HASH_SLAM:
        case 1464:
        case 8820:
        case 11430:
        case 11604:
        case 11605:
        case 25241:
        case 25242:
        case 34620:
        case 47474:
        case 47475:
        case 50782:
        case 50783:
        case 52026:
        case 67028:
        {
            if (p_caster != nullptr)
            {
                auto mainHand = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                if (mainHand != nullptr)
                {
                    float avgWeaponDmg = (mainHand->getItemProperties()->Damage[0].Max + mainHand->getItemProperties()->Damage[0].Min) / 2;
                    value += Util::float2int32((getSpellInfo()->calculateEffectValue(0)) + avgWeaponDmg);
                }
            }
        } break;
 
        // SPELL_HASH_EVISCERATE:
        case 2098:
        case 6760:
        case 6761:
        case 6762:
        case 8623:
        case 8624:
        case 11299:
        case 11300:
        case 15691:
        case 15692:
        case 26865:
        case 27611:
        case 31016:
        case 41177:
        case 46189:
        case 48667:
        case 48668:
        case 57641:
        case 60008:
        case 65957:
        case 67709:
        case 68094:
        case 68095:
        case 68096:
        case 68317:
        case 71933:
        {
            if (p_caster != nullptr)
                value += (uint32_t)(p_caster->getCalculatedAttackPower() * 0.03f * p_caster->getComboPoints());
        } break;
 
        // SPELL_HASH_FEROCIOUS_BITE:
        case 22568:
        case 22827:
        case 22828:
        case 22829:
        case 24248:
        case 27557:
        case 31018:
        case 48576:
        case 48577:
        {
            if (p_caster != nullptr)
            {
                value += (uint32_t)((p_caster->getCalculatedAttackPower() * 0.1526f) + (p_caster->getPower(POWER_TYPE_ENERGY) * getSpellInfo()->getEffectDamageMultiplier(static_cast<uint8_t>(i))));
                p_caster->setPower(POWER_TYPE_ENERGY, 0);
            }
        } break;
 
        // SPELL_HASH_VICTORY_RUSH:
        case 34428:
        {
            //causing ${$AP*$m1/100} damage
            if (u_caster != nullptr && i == 0)
                value = (value * u_caster->getCalculatedAttackPower()) / 100;
        } break;
 
        // SPELL_HASH_RAKE:
        case 1822:
        case 1823:
        case 1824:
        case 9904:
        case 24331:
        case 24332:
        case 27003:
        case 27556:
        case 27638:
        case 36332:
        case 48573:
        case 48574:
        case 53499:
        case 54668:
        case 59881:
        case 59882:
        case 59883:
        case 59884:
        case 59885:
        case 59886:
        {
            //Rake the target for ${$AP/100+$m1} bleed damage and an additional ${$m2*3+$AP*0.06} damage over $d.
            if (u_caster != nullptr)
            {
                float ap = float(u_caster->getCalculatedAttackPower());
                if (i == 0)
                    value += Util::float2int32(ceilf(ap * 0.01f)); // / 100
                else if (i == 1)
                    value += Util::float2int32(ap * 0.06f);
            }
        } break;
 
        // SPELL_HASH_GARROTE:
        case 703:
        case 8631:
        case 8632:
        case 8633:
        case 8818:
        case 11289:
        case 11290:
        case 26839:
        case 26884:
        case 37066:
        case 48675:
        case 48676:
        {
            // WoWWiki says +(0.18 * attack power / number of ticks)
            // Tooltip gives no specific reading, but says ", increased by your attack power.".
            if (u_caster != nullptr && i == 0)
                value += (uint32_t)ceilf((u_caster->getCalculatedAttackPower() * 0.07f) / 6);
        } break;
 
        // SPELL_HASH_RUPTURE:
        case 1943:
        case 8639:
        case 8640:
        case 11273:
        case 11274:
        case 11275:
        case 14874:
        case 14903:
        case 15583:
        case 26867:
        case 48671:
        case 48672:
        {
            /*
            1pt = Attack Power * 0.04 + x
            2pt = Attack Power * 0.10 + y
            3pt = Attack Power * 0.18 + z
            4pt = Attack Power * 0.21 + a
            5pt = Attack Power * 0.24 + b
            */
            if (p_caster != nullptr && i == 0)
            {
                int8_t cp = p_caster->getComboPoints();
                value += (uint32_t)ceilf((u_caster->getCalculatedAttackPower() * 0.04f * cp) / ((6 + (cp << 1)) >> 1));
            }
        } break;
 
        // SPELL_HASH_RIP:
        case 1079:
        case 9492:
        case 9493:
        case 9752:
        case 9894:
        case 9896:
        case 27008:
        case 33912:
        case 36590:
        case 49799:
        case 49800:
        case 57661:
        case 59989:
        case 71926:
        {
            if (p_caster != nullptr)
                value += Util::float2int32(p_caster->getCalculatedAttackPower() * 0.01f * p_caster->getComboPoints());
        } break;
 
        // SPELL_HASH_MONGOOSE_BITE:
        case 1495:
        case 14269:
        case 14270:
        case 14271:
        case 36916:
        case 53339:
        {
            // ${$AP*0.2+$m1} damage.
            if (u_caster != nullptr)
                value += u_caster->getCalculatedAttackPower() / 5;
        } break;
 
        // SPELL_HASH_SWIPE:
        case 27554:
        case 31279:
        case 50256:
        case 53498:
        case 53526:
        case 53528:
        case 53529:
        case 53532:
        case 53533:
        {
            // ${$AP*0.06+$m1} damage.
            if (u_caster != nullptr)
                value += Util::float2int32(u_caster->getCalculatedAttackPower() * 0.06f);
        } break;
 
        // SPELL_HASH_HAMMER_OF_THE_RIGHTEOUS:
        case 53595:
        case 54423:
        case 66867:
        case 66903:
        case 66904:
        case 66905:
        case 67680:
        {
            if (p_caster != nullptr)
                //4x 1h weapon-dps ->  4*(mindmg+maxdmg)/speed/2 = 2*(mindmg+maxdmg)/speed
                value = Util::float2int32((p_caster->getMinDamage() + p_caster->getMaxDamage()) / (float(p_caster->getBaseAttackTime(MELEE)) / 1000.0f)) << 1;
        } break;
 
        // SPELL_HASH_BACKSTAB:  // Egari: spell 31220 is interfering with combopoints
        case 53:
        case 2589:
        case 2590:
        case 2591:
        case 7159:
        case 8721:
        case 11279:
        case 11280:
        case 11281:
        case 15582:
        case 15657:
        case 22416:
        case 25300:
        case 26863:
        case 30992:
        case 34614:
        case 37685:
        case 48656:
        case 48657:
        case 52540:
        case 58471:
        case 63754:
        case 71410:
        case 72427:
        {
            if (i == 2)
                return getSpellInfo()->getEffectBasePoints(static_cast<uint8_t>(i)) + 1;
        } break;
 
        // SPELL_HASH_FAN_OF_KNIVES:  // rogue - fan of knives
        case 51723:
        case 52874:
        case 61739:
        case 61740:
        case 61741:
        case 61742:
        case 61743:
        case 61744:
        case 61745:
        case 61746:
        case 63753:
        case 65955:
        case 67706:
        case 68097:
        case 68098:
        case 68099:
        case 69921:
        case 71128:
        {
            if (p_caster != nullptr)
            {
                Item* mit = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                if (mit != nullptr)
                {
                    if (mit->getItemProperties()->Class == 2 && mit->getItemProperties()->SubClass == 15)   // daggers
                        value = 105;
                }
            }
        } break;
 
        // SPELL_HASH_SEAL_OF_RIGHTEOUSNESS:
        case 20154:
        case 21084:
        case 25742:
        {
            if (p_caster != nullptr)
            {
                Item* mit = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                if (mit != nullptr)
                    value = (p_caster->getCalculatedAttackPower() * 22 + p_caster->getModDamageDonePositive(SCHOOL_HOLY) * 44) * mit->getItemProperties()->Delay / 1000000;
            }
        } break;
 
        // SPELL_HASH_BLOOD_CORRUPTION:
        case 53742:
        // SPELL_HASH_HOLY_VENGEANCE:
        case 31803:
        {
            if (p_caster != nullptr)
                value = (p_caster->getCalculatedAttackPower() * 25 + p_caster->getModDamageDonePositive(SCHOOL_HOLY) * 13) / 1000;
        } break;
 
        // SPELL_HASH_JUDGEMENT:
        case 10321:
        case 23590:
        case 23591:
        case 35170:
        case 41467:
        case 43838:
        case 54158:
        {
            if (p_caster != nullptr)
                value += (p_caster->getCalculatedAttackPower() * 16 + p_caster->getModDamageDonePositive(SCHOOL_HOLY) * 25) / 100;
        } break;
 
        // SPELL_HASH_JUDGEMENT_OF_RIGHTEOUSNESS:
        case 20187:
        {
            if (p_caster != nullptr)
                value += (p_caster->getCalculatedAttackPower() * 2 + p_caster->getModDamageDonePositive(SCHOOL_HOLY) * 32) / 100;
        } break;
 
        // SPELL_HASH_JUDGEMENT_OF_VENGEANCE:
        case 31804:
        // SPELL_HASH_JUDGEMENT_OF_CORRUPTION:
        case 53733:
        {
            if (p_caster != nullptr)
                value += (p_caster->getCalculatedAttackPower() * 14 + p_caster->getModDamageDonePositive(SCHOOL_HOLY) * 22) / 100;
        } break;
 
        // SPELL_HASH_ENVENOM:
        case 32645:
        case 32684:
        case 39967:
        case 41487:
        case 41509:
        case 41510:
        case 57992:
        case 57993:
        {
            if (p_caster != nullptr && i == 0)
            {
                value *= p_caster->getComboPoints();
                value += (uint32_t)(p_caster->getCalculatedAttackPower() * (0.09f * p_caster->getComboPoints()));
            }
        } break;
 
        //SPELL_HASH_GOUGE
        case 1776:
        case 1777:
        case 8629:
        case 11285:
        case 11286:
        case 12540:
        case 13579:
        case 24698:
        case 28456:
        case 29425:
        case 34940:
        case 36862:
        case 38764:
        case 38863:
        {
            if (u_caster != nullptr && i == 0)
                value += (uint32_t)ceilf(u_caster->getCalculatedAttackPower() * 0.21f);
        } break;
        default:
        {
            handled = false;
        } break;
    }
 
    if (!handled)
    {
        //it will be set to false in the default case of the switch.
        handled = true;
        switch (getSpellInfo()->getId())
        {
            case 34123:  //Druid - Tree of Life
            {
                if (p_caster != nullptr && i == 0)
                    //Heal is increased by 6%
                    value = Util::float2int32(value * 1.06f);
                break;
            }
            case 57669: //Replenishment
            case 61782:
            {
                if (p_caster != nullptr && i == 0 && target != nullptr)
                    value = int32_t(0.002 * target->getMaxPower(POWER_TYPE_MANA));
                break;
            }
            default:
            {
                //not handled in this switch
                handled = false;
                break;
            }
        }
 
        if (!handled)
        {
            if (getSpellInfo()->custom_c_is_flags & SPELL_FLAG_IS_POISON && u_caster != nullptr)   // poison damage modifier
            {
                switch (getSpellInfo()->getId())
                {
                    // SPELL_HASH_DEADLY_POISON_IX:
                    case 57970:
                    case 57973:
                    // SPELL_HASH_DEADLY_POISON_VIII:
                    case 57969:
                    case 57972:
                    // SPELL_HASH_DEADLY_POISON_VII:
                    case 27186:
                    case 27187:
                    // SPELL_HASH_DEADLY_POISON_VI:
                    case 26967:
                    case 26968:
                    // SPELL_HASH_DEADLY_POISON_V:
                    case 25349:
                    case 25351:
                    // SPELL_HASH_DEADLY_POISON_IV:
                    case 11354:
                    case 11356:
                    // SPELL_HASH_DEADLY_POISON_III:
                    case 11353:
                    case 11355:
                    // SPELL_HASH_DEADLY_POISON_II:
                    case 2819:
                    case 2824:
                    // SPELL_HASH_DEADLY_POISON:
                    case 2818:
                    case 2823:
                    case 3583:
                    case 10022:
                    case 13582:
                    case 21787:
                    case 21788:
                    case 32970:
                    case 32971:
                    case 34616:
                    case 34655:
                    case 34657:
                    case 36872:
                    case 38519:
                    case 38520:
                    case 41191:
                    case 41192:
                    case 41485:
                    case 43580:
                    case 43581:
                    case 56145:
                    case 56149:
                    case 59479:
                    case 59482:
                    case 63755:
                    case 63756:
                    case 67710:
                    case 67711:
                    case 68315:
                    case 72329:
                    case 72330:
                        if (getSpellInfo()->getEffectApplyAuraName(static_cast<uint8_t>(i)) == SPELL_AURA_PERIODIC_DAMAGE)
                            value += Util::float2int32(u_caster->getCalculatedAttackPower() * 0.03f);
                        break;
                    // SPELL_HASH_INSTANT_POISON_IX:
                    case 57965:
                    case 57968:
                    // SPELL_HASH_INSTANT_POISON_VIII:
                    case 57964:
                    case 57967:
                    // SPELL_HASH_INSTANT_POISON_VII:
                    case 26890:
                    case 26891:
                    // SPELL_HASH_INSTANT_POISON_VI:
                    case 11337:
                    case 11340:
                    // SPELL_HASH_INSTANT_POISON_V:
                    case 11336:
                    case 11339:
                    // SPELL_HASH_INSTANT_POISON_IV:
                    case 11335:
                    case 11338:
                    // SPELL_HASH_INSTANT_POISON_III:
                    case 8688:
                    case 8689:
                    // SPELL_HASH_INSTANT_POISON_II:
                    case 8685:
                    case 8686:
                    // SPELL_HASH_INSTANT_POISON:
                    case 8679:
                    case 8680:
                    case 28428:
                    case 41189:
                    case 59242:
                        if (getSpellInfo()->getEffect(static_cast<uint8_t>(i)) == SPELL_EFFECT_SCHOOL_DAMAGE)
                            value += Util::float2int32(u_caster->getCalculatedAttackPower() * 0.10f);
                        break;
                    // SPELL_HASH_WOUND_POISON_VII:
                    case 57975:
                    case 57978:
                    // SPELL_HASH_WOUND_POISON_VI:
                    case 57974:
                    case 57977:
                    // SPELL_HASH_WOUND_POISON_V:
                    case 27188:
                    case 27189:
                    // SPELL_HASH_WOUND_POISON_IV:
                    case 13224:
                    case 13227:
                    // SPELL_HASH_WOUND_POISON_III:
                    case 13223:
                    case 13226:
                    // SPELL_HASH_WOUND_POISON_II:
                    case 13222:
                    case 13225:
                    // SPELL_HASH_WOUND_POISON:
                    case 13218:
                    case 13219:
                    case 30984:
                    case 36974:
                    case 39665:
                    case 43461:
                    case 54074:
                    case 65962:
                        if (getSpellInfo()->getEffect(static_cast<uint8_t>(i)) == SPELL_EFFECT_SCHOOL_DAMAGE)
                            value += Util::float2int32(u_caster->getCalculatedAttackPower() * 0.04f);
                        break;
                }
            }
        }
    }
 
    return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DuelSpellNoMoreValid()

bool Spell::DuelSpellNoMoreValid ( ) const

bool DuelSpellNoMoreValid() Tells if the Spell was being casted while dueling but now the duel is over

Returns: true if Spell is now invalid because the duel is over false if Spell is valid.

Definition at line 2906 of file Spell.Legacy.cpp.

{
    if (duelSpell && (
        (p_caster != nullptr && p_caster->getDuelState() != DUEL_STATE_STARTED) ||
        (u_caster != nullptr && u_caster->isPet() && static_cast<Pet*>(u_caster)->getPlayerOwner() && static_cast<Pet*>(u_caster)->getPlayerOwner()->getDuelState() != DUEL_STATE_STARTED)))
        return true;
    else
        return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FillAllFriendlyInArea()

void Spell::FillAllFriendlyInArea	(	uint32_t	i,
		float	srcx,
		float	srcy,
		float	srcz,
		float	range
	)

Definition at line 247 of file Spell.Legacy.cpp.

{
    std::vector<uint64_t>* tmpMap = &m_effectTargets[i];
    float r = range * range;
    SpellDidHitResult did_hit_result;
 
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        if (itr)
        {
            auto obj = itr;
            if (!(itr->isCreatureOrPlayer()) || !static_cast<Unit*>(itr)->isAlive())
                continue;
 
            if (getSpellInfo()->getTargetCreatureType())
            {
                if (!itr->isCreature())
                    continue;
                CreatureProperties const* inf = static_cast<Creature*>(itr)->GetCreatureProperties();
                if (!(1 << (inf->Type - 1) & getSpellInfo()->getTargetCreatureType()))
                    continue;
            }
 
            if (obj->isInRange(srcx, srcy, srcz, r))
            {
                if (worldConfig.terrainCollision.isCollisionEnabled)
                {
                    bool isInLOS = m_caster->IsWithinLOSInMap(itr);
 
                    if (m_caster->GetMapId() == itr->GetMapId() && !isInLOS)
                        continue;
                }
 
                if (u_caster != nullptr)
                {
                    if (u_caster->isFriendlyTo(itr))
                    {
                        did_hit_result = static_cast<SpellDidHitResult>(DidHit(i, static_cast<Unit*>(itr)));
                        if (did_hit_result == SPELL_DID_HIT_SUCCESS)
                            SafeAddTarget(tmpMap, itr->getGuid());
                        else
                            safeAddMissedTarget(itr->getGuid(), did_hit_result, SPELL_DID_HIT_SUCCESS);
                    }
                }
                else //cast from GO
                {
                    if (g_caster != nullptr && g_caster->getCreatedByGuid() && g_caster->getUnitOwner() != nullptr)
                    {
                        //trap, check not to attack owner and friendly
                        if (g_caster->getUnitOwner()->isFriendlyTo(itr))
                            SafeAddTarget(tmpMap, itr->getGuid());
                    }
                    else
                        SafeAddTarget(tmpMap, itr->getGuid());
                }
                if (getSpellInfo()->getMaxTargets())
                    if (getSpellInfo()->getMaxTargets() == tmpMap->size())
                        return;
            }
        }
    }
}

Here is the call graph for this function:

◆ FillAllTargetsInArea() [1/3]

void Spell::FillAllTargetsInArea	(	float	srcx,
		float	srcy,
		float	srcz,
		uint32_t	ind
	)

Definition at line 170 of file Spell.Legacy.cpp.

{
    FillAllTargetsInArea(ind, srcx, srcy, srcz, getEffectRadius(ind));
}

Here is the call graph for this function:

◆ FillAllTargetsInArea() [2/3]

void Spell::FillAllTargetsInArea	(	LocationVector &	location,
		uint32_t	ind
	)

Definition at line 165 of file Spell.Legacy.cpp.

{
    FillAllTargetsInArea(ind, location.x, location.y, location.z, getEffectRadius(ind));
}

Here is the call graph for this function:

◆ FillAllTargetsInArea() [3/3]

void Spell::FillAllTargetsInArea	(	uint32_t	i,
		float	srcx,
		float	srcy,
		float	srcz,
		float	range
	)

Definition at line 176 of file Spell.Legacy.cpp.

{
    std::vector<uint64_t>* tmpMap = &m_effectTargets[i];
    float r = range * range;
    SpellDidHitResult did_hit_result;
 
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        if (itr)
        {
            auto obj = itr;
            if (!itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())      //|| (TO< Creature* >(*itr)->isTotem() && !TO< Unit* >(*itr)->isPlayer())) why shouldn't we fill totems?
                continue;
 
            if (p_caster && (itr)->isPlayer() && p_caster->getGroup() && static_cast<Player*>(itr)->getGroup() && static_cast<Player*>(itr)->getGroup() == p_caster->getGroup())      //Don't attack party members!!
            {
                //Dueling - AoE's should still hit the target party member if you're dueling with him
                if (!p_caster->getDuelPlayer() || p_caster->getDuelPlayer() != static_cast<Player*>(itr))
                    continue;
            }
            if (getSpellInfo()->getTargetCreatureType())
            {
                if (!itr->isCreature())
                    continue;
                CreatureProperties const* inf = static_cast<Creature*>(itr)->GetCreatureProperties();
                if (!(1 << (inf->Type - 1) & getSpellInfo()->getTargetCreatureType()))
                    continue;
            }
            if (obj->isInRange(srcx, srcy, srcz, r))
            {
                if (worldConfig.terrainCollision.isCollisionEnabled)
                {
                    bool isInLOS = m_caster->IsWithinLOSInMap(itr);
 
                    if (m_caster->GetMapId() == itr->GetMapId() && !isInLOS)
                        continue;
                }
 
                if (u_caster != nullptr)
                {
                    if (u_caster->isValidTarget(itr, getSpellInfo()))
                    {
                        did_hit_result = static_cast<SpellDidHitResult>(DidHit(i, static_cast<Unit*>(itr)));
                        if (did_hit_result == SPELL_DID_HIT_SUCCESS)
                            SafeAddTarget(tmpMap, itr->getGuid());
                        else
                            safeAddMissedTarget(itr->getGuid(), did_hit_result, SPELL_DID_HIT_SUCCESS);
                    }
                }
                else //cast from GO
                {
                    if (g_caster != nullptr && g_caster->getCreatedByGuid() && g_caster->getUnitOwner() != nullptr)
                    {
                        //trap, check not to attack owner and friendly
                        if (g_caster->getUnitOwner()->isValidTarget(itr, getSpellInfo()))
                            SafeAddTarget(tmpMap, itr->getGuid());
                    }
                    else
                        SafeAddTarget(tmpMap, itr->getGuid());
                }
                if (getSpellInfo()->getMaxTargets())
                    if (getSpellInfo()->getMaxTargets() == tmpMap->size())
                    {
                        return;
                    }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FillSpecifiedTargetsInArea() [1/2]

void Spell::FillSpecifiedTargetsInArea	(	float	srcx,
		float	srcy,
		float	srcz,
		uint32_t	ind,
		uint32_t	specification
	)

Definition at line 101 of file Spell.Legacy.cpp.

{
    FillSpecifiedTargetsInArea(ind, srcx, srcy, srcz, getEffectRadius(ind), specification);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FillSpecifiedTargetsInArea() [2/2]

void Spell::FillSpecifiedTargetsInArea	(	uint32_t	i,
		float	srcx,
		float	srcy,
		float	srcz,
		float	range,
		uint32_t	specification
	)

Definition at line 107 of file Spell.Legacy.cpp.

{
    std::vector<uint64_t>* tmpMap = &m_effectTargets[i];
    //IsStealth()
    float r = range * range;
    SpellDidHitResult did_hit_result;
 
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        auto obj = itr;
        // don't add objects that are not units and that are dead
        if (!obj || !obj->isCreatureOrPlayer() || !static_cast<Unit*>(obj)->isAlive())
            continue;
 
        if (getSpellInfo()->getTargetCreatureType())
        {
            if (!obj->isCreature())
                continue;
            CreatureProperties const* inf = static_cast<Creature*>(obj)->GetCreatureProperties();
            if (!(1 << (inf->Type - 1) & getSpellInfo()->getTargetCreatureType()))
                continue;
        }
 
        if (obj->isInRange(srcx, srcy, srcz, r))
        {
            if (u_caster != nullptr)
            {
                if (u_caster->isValidTarget(itr, getSpellInfo()))
                {
                    did_hit_result = static_cast<SpellDidHitResult>(DidHit(i, static_cast<Unit*>(itr)));
                    if (did_hit_result != SPELL_DID_HIT_SUCCESS)
                        safeAddMissedTarget(itr->getGuid(), did_hit_result, SPELL_DID_HIT_SUCCESS);
                    else
                        SafeAddTarget(tmpMap, itr->getGuid());
                }
 
            }
            else //cast from GO
            {
                if (g_caster && g_caster->getCreatedByGuid() && g_caster->getUnitOwner())
                {
                    //trap, check not to attack owner and friendly
                    if (g_caster->getUnitOwner()->isValidTarget(itr, getSpellInfo()))
                        SafeAddTarget(tmpMap, itr->getGuid());
                }
                else
                    SafeAddTarget(tmpMap, itr->getGuid());
            }
            if (getSpellInfo()->getMaxTargets())
            {
                if (getSpellInfo()->getMaxTargets() >= tmpMap->size())
                {
                    return;
                }
            }
        }
    }
}

Here is the call graph for this function:

◆ FillTargetMap()

void Spell::FillTargetMap ( uint32_t i )

Todo:: arcemu, doesn't support summon slots?

Definition at line 39 of file SpellTarget.Legacy.cpp.

{
    //Spell::prepare() has already a m_caster->IsInWorld() check so if now the caster is no more in world something bad happened.
    if (!m_caster->IsInWorld())
        return;
 
    uint32_t TargetType = 0;
    TargetType |= getSpellInfo()->getRequiredTargetMaskForEffect(static_cast<uint8_t>(i));
 
    if (TargetType & SPELL_TARGET_NOT_IMPLEMENTED)
        return;
    if (TargetType == SPELL_TARGET_NO_OBJECT)  //summon spells that appear infront of caster
    {
        HandleTargetNoObject();
        return;
    }
 
    //always add this guy :P
    if (!(TargetType & (SPELL_TARGET_AREA | SPELL_TARGET_AREA_SELF | SPELL_TARGET_AREA_CURTARGET | SPELL_TARGET_AREA_CONE | SPELL_TARGET_OBJECT_SELF | SPELL_TARGET_OBJECT_PETOWNER)))
    {
        Object* target = nullptr;
        if (TargetType & SPELL_TARGET_REQUIRE_GAMEOBJECT)
            target = m_caster->getWorldMapObject(m_targets.getGameObjectTargetGuid());
        else if (TargetType & SPELL_TARGET_REQUIRE_ITEM)
            target = m_caster->getWorldMapObject(m_targets.getItemTargetGuid());
 
        // If target was not found, try unit
        if (target == nullptr)
            target = m_caster->getWorldMapObject(m_targets.getUnitTargetGuid());
 
        AddTarget(i, TargetType, target);
    }
 
    if (TargetType & SPELL_TARGET_OBJECT_SELF)
        AddTarget(i, TargetType, m_caster);
    if (TargetType & (SPELL_TARGET_AREA | SPELL_TARGET_AREA_SELF))  //targetted aoe
        AddAOETargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets());
    ///\todo arcemu, doesn't support summon slots?
    /*if (TargetType & SPELL_TARGET_OBJECT_CURTOTEMS && u_caster != NULL)
        for (uint32_t i=1; i<5; ++i) //totem slots are 1, 2, 3, 4
        AddTarget(i, TargetType, u_caster->m_summonslot[i]);*/
    if (TargetType & SPELL_TARGET_OBJECT_CURPET && u_caster != nullptr)
        AddTarget(i, TargetType, u_caster->getPet());
    if (TargetType & SPELL_TARGET_OBJECT_PETOWNER)
    {
        WoWGuid wowGuid;
        wowGuid.Init(m_targets.getUnitTargetGuid());
        if (wowGuid.isPet())
        {
            Pet* p = m_caster->getWorldMap()->getPet(wowGuid.getGuidLowPart());
            if (p != nullptr)
                AddTarget(i, TargetType, p->getUnitOwner());
        }
    }
    //targets party, not raid
    if ((TargetType & SPELL_TARGET_AREA_PARTY) && !(TargetType & SPELL_TARGET_AREA_RAID))
    {
        if (p_caster == nullptr && !m_caster->isPet() && (!m_caster->isCreature() || !m_caster->isTotem()))
            AddAOETargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets()); //npcs
        else
            AddPartyTargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets()); //players/pets/totems
    }
    if (TargetType & SPELL_TARGET_AREA_RAID)
    {
        if (p_caster == nullptr && !m_caster->isPet() && (!m_caster->isCreature() || !m_caster->isTotem()))
            AddAOETargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets()); //npcs
        else
            AddRaidTargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets(), (TargetType & SPELL_TARGET_AREA_PARTY) ? true : false); //players/pets/totems
    }
    if (TargetType & SPELL_TARGET_AREA_CHAIN)
        AddChainTargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets());
    //target cone
    if (TargetType & SPELL_TARGET_AREA_CONE)
        AddConeTargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets());
 
    if (TargetType & SPELL_TARGET_OBJECT_SCRIPTED)
        AddScriptedOrSpellFocusTargets(i, TargetType, getEffectRadius(i), m_spellInfo->getMaxTargets());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ finish()

void Spell::finish ( bool successful = true )

Definition at line 1076 of file Spell.cpp.

{
    if (getState() == SPELL_STATE_FINISHED)
        return;
 
    m_spellState = SPELL_STATE_FINISHED;
 
    // Caster could be nullptr at this point
    if (getCaster() == nullptr)
    {
        delete this;
        return;
    }
 
    // Clear spell cooldown if player has cooldown cheat
    if (!m_triggeredSpell && getPlayerCaster() != nullptr && getPlayerCaster()->m_cheats.hasCooldownCheat)
        getPlayerCaster()->clearCooldownForSpell(getSpellInfo()->getId());
 
    // No need to do anything else on failed spells
    if (!successful)
    {
        getCaster()->removeTravelingSpell(this);
        return;
    }
 
    // Unit spell script hooks
    if (getUnitCaster() != nullptr)
    {
        if (getUnitCaster()->IsInWorld() && getUnitCaster()->isCreature() && dynamic_cast<Creature*>(getUnitCaster())->GetScript())
            dynamic_cast<Creature*>(getUnitCaster())->GetScript()->OnCastSpell(getSpellInfo()->getId());
 
        if (!sEventMgr.HasEvent(getUnitCaster(), EVENT_CREATURE_RESPAWN))
        {
            for (const auto& uniqueTarget : m_uniqueHittedTargets)
            {
                auto* const targetUnit = getUnitCaster()->getWorldMapUnit(uniqueTarget.first);
                if (targetUnit == nullptr)
                    continue;
 
                if (getUnitCaster()->IsInWorld() && getUnitCaster()->isCreature() && dynamic_cast<Creature*>(getUnitCaster())->GetScript())
                    dynamic_cast<Creature*>(getUnitCaster())->GetScript()->OnSpellHitTarget(targetUnit, getSpellInfo());
 
                if (!targetUnit->isCreature())
                    continue;
 
                auto* const targetCreature = dynamic_cast<Creature*>(targetUnit);
                if (targetCreature->IsInWorld() && targetCreature->isCreature() && targetCreature->GetScript())
                    targetCreature->GetScript()->OnHitBySpell(getSpellInfo()->getId(), getUnitCaster());
            }
        }
 
        u_caster->m_canMove = true;
    }
 
    // Recheck used spell modifiers
    takeUsedSpellModifiers();
 
    if (getPlayerCaster() != nullptr)
    {
        if (getSpellInfo()->getAttributes() & ATTRIBUTES_STOP_ATTACK && getPlayerCaster()->isAttacking())
        {
            getPlayerCaster()->eventAttackStop();
            getPlayerCaster()->smsg_AttackStop(getPlayerCaster()->getWorldMapUnit(getPlayerCaster()->getTargetGuid()));
            getPlayerCaster()->sendPacket(SmsgCancelCombat().serialise().get());
        }
 
        if (m_Delayed)
        {
            auto target = getPlayerCaster()->getWorldMapUnit(getPlayerCaster()->getChannelObjectGuid());
            if (target == nullptr)
                target = getPlayerCaster()->getWorldMapUnit(getPlayerCaster()->getTargetGuid());
 
            if (target != nullptr)
                target->removeAllAurasByIdForGuid(getSpellInfo()->getId(), getCaster()->getGuid());
        }
 
        if (getSpellInfo()->hasEffect(SPELL_EFFECT_SUMMON_OBJECT))
            getPlayerCaster()->setSummonedObject(nullptr);
 
        // Clear combo points before spell procs
        if (m_requiresCP && !GetSpellFailed())
        {
            // Save used combo point count for some proc spells
            m_usedComboPoints = getPlayerCaster()->getComboPoints();
 
            getPlayerCaster()->clearComboPoints();
        }
    }
 
    // Handle procs for each target
    Unit* targetUnit = nullptr;
    if (m_targetProcFlags != 0)
    {
        // Handle each target's procs to caster
        for (const auto& uniqueTarget : m_uniqueHittedTargets)
        {
            // Check if this target has already handled procs
            if (m_doneTargetProcs.find(uniqueTarget.first) != m_doneTargetProcs.end())
                continue;
 
            targetUnit = getCaster()->getWorldMapUnit(uniqueTarget.first);
            if (targetUnit == nullptr)
                continue;
 
            const auto targetProcFlags = m_targetProcFlags | m_casterDamageInfo.victimProcFlags;
            targetUnit->handleProc(targetProcFlags, getUnitCaster(), getSpellInfo(), uniqueTarget.second, m_triggeredSpell, PROC_EVENT_DO_ALL, m_triggeredByAura);
        }
    }
 
    // Handle caster procs
    targetUnit = nullptr;
    if (getUnitCaster() != nullptr && m_casterProcFlags != 0)
    {
        // Handle caster's procs to each target
        for (const auto& uniqueTarget : m_uniqueHittedTargets)
        {
            auto casterProcFlags = m_casterProcFlags | m_casterDamageInfo.attackerProcFlags;
            // If caster is target, remove following proc flags
            if (uniqueTarget.first == m_caster->getGuid())
                casterProcFlags &= ~(PROC_ON_DONE_MELEE_SPELL_HIT | PROC_ON_DONE_RANGED_SPELL_HIT);
 
            targetUnit = getCaster()->getWorldMapUnit(uniqueTarget.first);
            if (targetUnit == nullptr)
                continue;
 
            getUnitCaster()->handleProc(casterProcFlags, targetUnit, getSpellInfo(), uniqueTarget.second, m_triggeredSpell, PROC_EVENT_DO_TARGET_PROCS_ONLY, m_triggeredByAura);
        }
 
        // Use victim only if there was one target
        if (m_uniqueHittedTargets.size() == 1)
            targetUnit = getCaster()->getWorldMapUnit(m_uniqueHittedTargets.front().first);
        else
            targetUnit = nullptr;
 
        // Handle caster's self procs
        const auto casterProcFlags = m_casterProcFlags | m_casterDamageInfo.attackerProcFlags;
        getUnitCaster()->handleProc(casterProcFlags, targetUnit, getSpellInfo(), m_casterDamageInfo, m_triggeredSpell, PROC_EVENT_DO_CASTER_PROCS_ONLY, m_triggeredByAura);
    }
 
    // QuestMgr spell hooks and achievement calls
    if (getUnitCaster() != nullptr)
    {
        // Skip 'on next attack' spells if spell is not triggered
        // this will be handled on the actual spell cast
        if (!(getSpellInfo()->isOnNextMeleeAttack() && !m_triggeredSpell))
        {
            uint32_t targetCount = 0;
            for (auto& target : m_uniqueHittedTargets)
            {
                WoWGuid wowGuid;
                wowGuid.Init(target.first);
                // If target is creature
                if (wowGuid.isUnit() && getPlayerCaster() != nullptr && getPlayerCaster()->IsInWorld())
                {
                    ++targetCount;
                    sQuestMgr.OnPlayerCast(getPlayerCaster(), getSpellInfo()->getId(), target.first);
                }
#ifdef FT_ACHIEVEMENTS
                else if (wowGuid.isPlayer())
                {
                    auto* const targetPlayer = getUnitCaster()->getWorldMapPlayer(target.first);
                    if (targetPlayer != nullptr)
                    {
                        targetPlayer->updateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, getSpellInfo()->getId(), 0, 0, u_caster);
                        targetPlayer->updateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET2, getSpellInfo()->getId(), 0, 0, u_caster);
                    }
                }
#endif
            }
 
            if (getPlayerCaster() != nullptr && getPlayerCaster()->IsInWorld())
            {
                if (targetCount == 0)
                {
                    auto guid = getPlayerCaster()->getTargetGuid();
                    sQuestMgr.OnPlayerCast(getPlayerCaster(), getSpellInfo()->getId(), guid);
                }
 
#ifdef FT_ACHIEVEMENTS
                // Set target for spell cast achievement only if spell had one target
                Object* spellTarget = nullptr;
                if (m_uniqueHittedTargets.size() == 1)
                    spellTarget = getPlayerCaster()->getWorldMapObject(m_uniqueHittedTargets.front().first);
 
                if (spellTarget && spellTarget->isCreatureOrPlayer())
                    getPlayerCaster()->updateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_CAST_SPELL2, getSpellInfo()->getId(), 0, 0, spellTarget->ToUnit());
#endif
            }
        }
    }
 
    // Spell is finished, remove it from traveling spells and delete it on next update tick
    getCaster()->removeTravelingSpell(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateTargets()

bool Spell::GenerateTargets ( SpellCastTargets * store_buff )

Definition at line 448 of file SpellTarget.Legacy.cpp.

{
    if (u_caster == nullptr || u_caster->getAIInterface() == nullptr || !u_caster->IsInWorld())
        return false;
 
    bool result = false;
 
    for (uint8_t i = 0; i < 3; ++i)
    {
        if (m_spellInfo->getEffect(i) == 0)
            continue;
        uint32_t TargetType = 0;
        TargetType |= getSpellInfo()->getRequiredTargetMaskForEffect(i);
 
        if (TargetType & (SPELL_TARGET_OBJECT_SELF | SPELL_TARGET_AREA_PARTY | SPELL_TARGET_AREA_RAID))
        {
            t->addTargetMask(TARGET_FLAG_UNIT);
            t->setUnitTarget(u_caster->getGuid());
            result = true;
        }
 
        if (TargetType & SPELL_TARGET_NO_OBJECT)
        {
            t->setTargetMask(TARGET_FLAG_SELF);
            result = true;
        }
 
        if (!(TargetType & (SPELL_TARGET_AREA | SPELL_TARGET_AREA_SELF | SPELL_TARGET_AREA_CURTARGET | SPELL_TARGET_AREA_CONE)))
        {
 
            if (TargetType & SPELL_TARGET_ANY_OBJECT)
            {
                if (u_caster->getTargetGuid())
                {
                    //generate targets for things like arcane missiles trigger, tame pet, etc
                    Object* target = u_caster->getWorldMap()->getObject(u_caster->getTargetGuid());
                    if (target != nullptr)
                    {
                        if (target->isCreatureOrPlayer())
                        {
                            t->addTargetMask(TARGET_FLAG_UNIT);
                            t->setUnitTarget(target->getGuid());
                            result = true;
                        }
                        else if (target->isGameObject())
                        {
                            t->addTargetMask(TARGET_FLAG_OBJECT);
                            t->setGameObjectTarget(target->getGuid());
                            result = true;
                        }
                    }
                    result = true;
                }
            }
 
            if (TargetType & SPELL_TARGET_REQUIRE_ATTACKABLE)
            {
                if (u_caster->getChannelObjectGuid())
                {
                    //generate targets for things like arcane missiles trigger, tame pet, etc
                    Object* target = u_caster->getWorldMap()->getObject(u_caster->getChannelObjectGuid());
                    if (target != nullptr)
                    {
                        if (target->isCreatureOrPlayer())
                        {
                            t->addTargetMask(TARGET_FLAG_UNIT);
                            t->setUnitTarget(target->getGuid());
                            result = true;
                        }
                        else if (target->isGameObject())
                        {
                            t->addTargetMask(TARGET_FLAG_OBJECT);
                            t->setGameObjectTarget(target->getGuid());
                            result = true;
                        }
                    }
                }
                else if (u_caster->getTargetGuid())
                {
                    //generate targets for things like arcane missiles trigger, tame pet, etc
                    Object* target = u_caster->getWorldMap()->getObject(u_caster->getTargetGuid());
                    if (target != nullptr)
                    {
                        if (target->isCreatureOrPlayer())
                        {
                            t->addTargetMask(TARGET_FLAG_UNIT);
                            t->setUnitTarget(target->getGuid());
                            result = true;
                        }
                        else if (target->isGameObject())
                        {
                            t->addTargetMask(TARGET_FLAG_OBJECT);
                            t->setGameObjectTarget(target->getGuid());
                            result = true;
                        }
                    }
                    result = true;
                }
                else if (u_caster->isCreature() && u_caster->isTotem())
                {
                    Unit* target = u_caster->getWorldMap()->getUnit(GetSinglePossibleEnemy(i));
                    if (target != nullptr)
                    {
                        t->addTargetMask(TARGET_FLAG_UNIT);
                        t->setUnitTarget(target->getGuid());
                    }
                }
            }
 
            if (TargetType & SPELL_TARGET_REQUIRE_FRIENDLY)
            {
                Unit* target = u_caster->getWorldMap()->getUnit(GetSinglePossibleFriend(i));
                if (target != nullptr)
                {
                    t->addTargetMask(TARGET_FLAG_UNIT);
                    t->setUnitTarget(target->getGuid());
                    result = true;
                }
                else
                {
                    t->addTargetMask(TARGET_FLAG_UNIT);
                    t->setUnitTarget(u_caster->getGuid());
                    result = true;
                }
            }
        }
 
        if (TargetType & SPELL_TARGET_AREA_RANDOM)
        {
            //we always use radius(0) for some reason
            bool isInLOS = false;
            uint8_t attempts = 0;
            do
            {
                //prevent deadlock
                ++attempts;
                if (attempts > 10)
                    return false;
 
                float r = Util::getRandomFloat(getEffectRadius(0));
                float ang = Util::getRandomFloat(M_PI_FLOAT * 2);
                auto lv = LocationVector();
                lv.x = m_caster->GetPositionX() + (cosf(ang) * r);
                lv.y = m_caster->GetPositionY() + (sinf(ang) * r);
                lv.z = m_caster->getMapHeight(LocationVector(lv.x, lv.y, m_caster->GetPositionZ() + 2.0f));
                t->setDestination(lv);
                t->setTargetMask(TARGET_FLAG_DEST_LOCATION);
 
                isInLOS = m_caster->IsWithinLOS(lv);
            }
            while (worldConfig.terrainCollision.isCollisionEnabled && !isInLOS);
            result = true;
        }
        else if (TargetType & SPELL_TARGET_AREA)  //targetted aoe
        {
            //spells like blizzard, rain of fire
            if (u_caster->getChannelObjectGuid())
            {
                Object* target = u_caster->getWorldMap()->getObject(u_caster->getChannelObjectGuid());
                if (target)
                {
                    t->addTargetMask(TARGET_FLAG_DEST_LOCATION | TARGET_FLAG_UNIT);
                    t->setDestination(target->GetPosition());
                }
                result = true;
            }
            else
            {
                if (u_caster->getAIInterface()->getCurrentTarget() != nullptr && TargetType & SPELL_TARGET_REQUIRE_ATTACKABLE)
                {
                    t->addTargetMask(TARGET_FLAG_DEST_LOCATION | TARGET_FLAG_UNIT);
                    t->setDestination(u_caster->getAIInterface()->getCurrentTarget()->GetPosition());
                    result = true;
                }
                else if (TargetType & SPELL_TARGET_REQUIRE_FRIENDLY)
                {
                    t->addTargetMask(TARGET_FLAG_DEST_LOCATION | TARGET_FLAG_UNIT);
                    t->setDestination(u_caster->GetPosition());
                    result = true;
                }
            }
        }
        else if (TargetType & SPELL_TARGET_AREA_SELF)
        {
            t->addTargetMask(TARGET_FLAG_SOURCE_LOCATION | TARGET_FLAG_UNIT);
            t->setUnitTarget(u_caster->getGuid());
            t->setSource(u_caster->GetPosition());
            t->setDestination(u_caster->GetPosition());
            result = true;
        }
 
        if (TargetType & SPELL_TARGET_AREA_CHAIN)
        {
            if (TargetType & SPELL_TARGET_REQUIRE_ATTACKABLE)
            {
                if (u_caster->getAIInterface()->getCurrentTarget() != nullptr)
                {
                    t->addTargetMask(TARGET_FLAG_UNIT);
                    t->setUnitTarget(u_caster->getAIInterface()->getCurrentTarget()->getGuid());
                    result = true;
                }
            }
            else
            {
                t->addTargetMask(TARGET_FLAG_UNIT);
                t->setUnitTarget(u_caster->getGuid());
                result = true;
            }
        }
        //target cone
        if (TargetType & SPELL_TARGET_AREA_CONE)
        {
            if (u_caster->getAIInterface()->getCurrentTarget() != nullptr)
            {
                t->addTargetMask(TARGET_FLAG_DEST_LOCATION);
                t->setDestination(u_caster->getAIInterface()->getCurrentTarget()->GetPosition());
                result = true;
            }
        }
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBaseThreat()

uint32_t Spell::GetBaseThreat ( uint32_t dmg )

static

Definition at line 1682 of file Spell.Legacy.cpp.

{
    //there should be a formula to determine what spell cause threat and which don't
    return dmg;
}

◆ getCaster()

Object * Spell::getCaster ( ) const

Definition at line 5629 of file Spell.cpp.

{
    return m_caster;
}

Here is the caller graph for this function:

◆ getCastTimeLeft()

int32_t Spell::getCastTimeLeft ( ) const

Definition at line 5545 of file Spell.cpp.

{
    return m_timer;
}

Here is the caller graph for this function:

◆ getCorpseTarget()

Corpse * Spell::getCorpseTarget ( ) const

Definition at line 5688 of file Spell.cpp.

5688{ return m_corpseTarget; }

◆ getDestination()

LocationVector Spell::getDestination ( )

inline

Definition at line 190 of file Spell.hpp.

190{ return m_targets.getDestination(); }

Here is the caller graph for this function:

◆ getDuration()

int32_t Spell::getDuration ( )

Definition at line 5910 of file Spell.cpp.

{
    if (isDurationSet)
        return m_duration;
 
    isDurationSet = true;
 
    if (!getSpellInfo()->getDurationIndex())
    {
        m_duration = -1;
        return m_duration;
    }
 
    const auto spellDuration = sSpellDurationStore.lookupEntry(getSpellInfo()->getDurationIndex());
    if (spellDuration == nullptr)
    {
        m_duration = -1;
        return m_duration;
    }
 
    // Duration affected by level
    if (getUnitCaster() != nullptr && spellDuration->Duration1 < 0 && spellDuration->Duration2)
    {
        m_duration = spellDuration->Duration1 + (spellDuration->Duration2 * static_cast<int32_t>(getUnitCaster()->getLevel()));
 
        if (m_duration > 0 && spellDuration->Duration3 > 0 && m_duration > spellDuration->Duration3)
            m_duration = spellDuration->Duration3;
 
        if (m_duration < 0)
            m_duration = 0;
    }
 
    if (m_duration == 0)
        m_duration = spellDuration->Duration1;
 
    // Check if duration is affected by combo points
    if (getPlayerCaster() != nullptr)
    {
        if (const auto comboPoints = getPlayerCaster()->getComboPoints())
        {
            const auto bonus = (comboPoints * (spellDuration->Duration3 - spellDuration->Duration1)) / 5;
            if (bonus)
                m_duration += bonus;
        }
    }
 
    if (getUnitCaster() != nullptr && m_duration > 0)
    {
        // Apply duration modifiers
        getUnitCaster()->applySpellModifiers(SPELLMOD_DURATION, &m_duration, getSpellInfo(), this);
 
        // Apply haste bonus
        if (getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_HASTE_AFFECTS_DURATION)
            m_duration = static_cast<int32_t>(m_duration * getUnitCaster()->getModCastSpeed());
    }
 
    return m_duration;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getEffectRadius()

float_t Spell::getEffectRadius ( uint8_t effectIndex )

Definition at line 5969 of file Spell.cpp.

{
    if (m_isEffectRadiusSet[effectIndex])
        return m_effectRadius[effectIndex];
 
    m_isEffectRadiusSet[effectIndex] = true;
    m_effectRadius[effectIndex] = ::GetRadius(sSpellRadiusStore.lookupEntry(getSpellInfo()->getEffectRadiusIndex(effectIndex)));
 
    // If spell has no effect radius set, use spell range instead
    // but skip for effect target 87. Otherwise some teleport spells like ICC teleports will target
    // all units in infinite range
    if (G3D::fuzzyEq(m_effectRadius[effectIndex], 0.f) &&
        getSpellInfo()->getEffectImplicitTargetA(effectIndex) != EFF_TARGET_AREA_DESTINATION && getSpellInfo()->getEffectImplicitTargetB(effectIndex) != EFF_TARGET_AREA_DESTINATION)
    {
        const auto rangeEntry = sSpellRangeStore.lookupEntry(getSpellInfo()->getRangeIndex());
        if (rangeEntry != nullptr)
        {
#if VERSION_STRING < WotLK
            m_effectRadius[effectIndex] = rangeEntry->maxRange;
#else
            const auto effectTargetMask = getSpellInfo()->getRequiredTargetMaskForEffect(effectIndex);
            m_effectRadius[effectIndex] = effectTargetMask & SPELL_TARGET_REQUIRE_ATTACKABLE ? rangeEntry->maxRange : rangeEntry->maxRangeFriendly;
#endif
        }
    }
 
    // Apply radius modifiers
    if (getUnitCaster() != nullptr)
        getUnitCaster()->applySpellModifiers(SPELLMOD_RADIUS, &m_effectRadius[effectIndex], getSpellInfo(), this);
 
    return m_effectRadius[effectIndex];
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getFullCastTime()

int32_t Spell::getFullCastTime ( ) const

Definition at line 5540 of file Spell.cpp.

{
    return m_castTime;
}

Here is the caller graph for this function:

◆ getGameObjectCaster()

GameObject * Spell::getGameObjectCaster ( ) const

Definition at line 5644 of file Spell.cpp.

{
    return g_caster;
}

Here is the caller graph for this function:

◆ getGameObjectTarget()

GameObject * Spell::getGameObjectTarget ( ) const

Definition at line 5686 of file Spell.cpp.

5686{ return m_gameObjTarget; }

Here is the caller graph for this function:

◆ getItemCaster()

Item * Spell::getItemCaster ( ) const

Definition at line 5649 of file Spell.cpp.

{
    return i_caster;
}

Here is the caller graph for this function:

◆ getItemTarget()

Item * Spell::getItemTarget ( ) const

Definition at line 5679 of file Spell.cpp.

5679{ return m_itemTarget; }

◆ GetMechanic()

uint32_t Spell::GetMechanic ( SpellInfo const * sp )

static

Definition at line 1688 of file Spell.Legacy.cpp.

{
    if (sp->getMechanicsType())
        return sp->getMechanicsType();
    if (sp->getEffectMechanic(2))
        return sp->getEffectMechanic(2);
    if (sp->getEffectMechanic(1))
        return sp->getEffectMechanic(1);
    if (sp->getEffectMechanic(0))
        return sp->getEffectMechanic(0);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPlayerCaster()

Player * Spell::getPlayerCaster ( ) const

Definition at line 5639 of file Spell.cpp.

{
    return p_caster;
}

◆ getPlayerTarget()

Player * Spell::getPlayerTarget ( ) const

Definition at line 5684 of file Spell.cpp.

5684{ return m_playerTarget; }

Here is the caller graph for this function:

◆ getPowerCost()

uint32_t Spell::getPowerCost ( ) const

Definition at line 5552 of file Spell.cpp.

{
    return m_powerCost;
}

Here is the caller graph for this function:

◆ GetSinglePossibleEnemy()

uint64_t Spell::GetSinglePossibleEnemy	(	uint32_t	i,
		float	prange = `0`
	)

Definition at line 310 of file Spell.Legacy.cpp.

{
    float r;
    if (prange)
        r = prange;
    else
    {
        r = getSpellInfo()->custom_base_range_or_radius_sqr;
        if (u_caster != nullptr)
        {
            u_caster->applySpellModifiers(SPELLMOD_RADIUS, &r, getSpellInfo(), this);
        }
    }
    float srcx = m_caster->GetPositionX(), srcy = m_caster->GetPositionY(), srcz = m_caster->GetPositionZ();
 
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        auto obj = itr;
        if (!obj || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
 
        if (getSpellInfo()->getTargetCreatureType())
        {
            if (!itr->isCreature())
                continue;
            CreatureProperties const* inf = static_cast<Creature*>(itr)->GetCreatureProperties();
            if (!(1 << (inf->Type - 1) & getSpellInfo()->getTargetCreatureType()))
                continue;
        }
        if (obj->isInRange(srcx, srcy, srcz, r))
        {
            if (u_caster != nullptr)
            {
                if (u_caster->isValidTarget(itr, getSpellInfo()) && DidHit(i, static_cast<Unit*>(itr)) == SPELL_DID_HIT_SUCCESS)
                {
                    return itr->getGuid();
                }
            }
            else //cast from GO
            {
                if (g_caster && g_caster->getCreatedByGuid() && g_caster->getUnitOwner())
                {
                    //trap, check not to attack owner and friendly
                    if (g_caster->getUnitOwner()->isValidTarget(itr, getSpellInfo()))
                    {
                        return itr->getGuid();
                    }
                }
            }
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSinglePossibleFriend()

uint64_t Spell::GetSinglePossibleFriend	(	uint32_t	i,
		float	prange = `0`
	)

Definition at line 364 of file Spell.Legacy.cpp.

{
    float r;
    if (prange)
        r = prange;
    else
    {
        r = getSpellInfo()->custom_base_range_or_radius_sqr;
        if (u_caster != nullptr)
        {
            u_caster->applySpellModifiers(SPELLMOD_RADIUS, &r, getSpellInfo(), this);
        }
    }
    float srcx = m_caster->GetPositionX(), srcy = m_caster->GetPositionY(), srcz = m_caster->GetPositionZ();
 
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        auto obj = itr;
        if (!obj || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
        if (getSpellInfo()->getTargetCreatureType())
        {
            if (!itr->isCreature())
                continue;
            CreatureProperties const* inf = static_cast<Creature*>(itr)->GetCreatureProperties();
            if (!(1 << (inf->Type - 1) & getSpellInfo()->getTargetCreatureType()))
                continue;
        }
        if (obj->isInRange(srcx, srcy, srcz, r))
        {
            if (u_caster != nullptr)
            {
                if (u_caster->isFriendlyTo(itr) && DidHit(i, static_cast<Unit*>(itr)) == SPELL_DID_HIT_SUCCESS)
                {
                    return itr->getGuid();
                }
            }
            else //cast from GO
            {
                if (g_caster && g_caster->getCreatedByGuid() && g_caster->getUnitOwner())
                {
                    //trap, check not to attack owner and friendly
                    if (g_caster->getUnitOwner()->isFriendlyTo(itr))
                    {
                        return itr->getGuid();
                    }
                }
            }
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getSource()

LocationVector Spell::getSource ( )

inline

Definition at line 191 of file Spell.hpp.

191{ return m_targets.getSource(); }

SpellCastTargets::getSource

LocationVector getSource() const

Definition SpellCastTargets.cpp:216

◆ GetSpellFailed()

bool Spell::GetSpellFailed ( ) const

Spell state's Spell failed

Definition at line 2916 of file Spell.Legacy.cpp.

{
    return m_Spell_Failed;
}

Here is the caller graph for this function:

◆ getSpellInfo()

SpellInfo const * Spell::getSpellInfo ( ) const

Definition at line 5789 of file Spell.cpp.

{
    return m_spellInfo_override != nullptr ? m_spellInfo_override : m_spellInfo;
}

◆ getState()

uint32_t Spell::getState ( ) const

Definition at line 2901 of file Spell.Legacy.cpp.

{
    return m_spellState;
}

Here is the caller graph for this function:

◆ getTargetConstraintCreature()

Creature * Spell::getTargetConstraintCreature ( ) const

Definition at line 5700 of file Spell.cpp.

5700{ return m_targetConstraintCreature; }

Spell::m_targetConstraintCreature

Creature * m_targetConstraintCreature

Definition Spell.hpp:212

Here is the caller graph for this function:

◆ getTargetConstraintGameObject()

GameObject * Spell::getTargetConstraintGameObject ( ) const

Definition at line 5703 of file Spell.cpp.

5703{ return m_targetConstraintGameObject; }

Spell::m_targetConstraintGameObject

GameObject * m_targetConstraintGameObject

Definition Spell.hpp:213

◆ getTriggeredByAura()

Aura * Spell::getTriggeredByAura ( ) const

Definition at line 5841 of file Spell.cpp.

{
    return m_triggeredByAura;
}

Here is the caller graph for this function:

◆ GetType()

uint32_t Spell::GetType ( )

Definition at line 2729 of file Spell.Legacy.cpp.

2729{ return (getSpellInfo()->getDmgClass() == SPELL_DMG_TYPE_NONE ? SPELL_DMG_TYPE_MAGIC : getSpellInfo()->getDmgClass()); }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getUnitCaster()

Unit * Spell::getUnitCaster ( ) const

Definition at line 5634 of file Spell.cpp.

{
    return u_caster;
}

◆ getUnitTarget()

Unit * Spell::getUnitTarget ( ) const

Definition at line 5682 of file Spell.cpp.

5682{ return m_unitTarget; }

◆ getUsedComboPoints()

int8_t Spell::getUsedComboPoints ( ) const

Definition at line 5846 of file Spell.cpp.

{
    return m_usedComboPoints;
}

◆ HandleAddAura()

void Spell::HandleAddAura ( uint64_t guid )

Definition at line 1242 of file Spell.Legacy.cpp.

{
    Unit* Target = nullptr;
 
    auto itr = m_pendingAuras.find(guid);
 
    if (itr == m_pendingAuras.end() || itr->second.aur == nullptr)
        return;
 
    //If this aura isn't added correctly it MUST be deleted
    auto&& aur = std::move(itr->second.aur);
 
    if (u_caster && u_caster->getGuid() == guid)
        Target = u_caster;
    else if (m_caster->IsInWorld())
        Target = m_caster->getWorldMap()->getUnit(guid);
 
    if (Target == nullptr)
    {
        return;
    }
 
    if (getUnitCaster() != nullptr)
    {
        if (getUnitCaster()->isFriendlyTo(Target))
        {
            Target->getCombatHandler().takeCombatAction(getUnitCaster(), true);
        }
        else if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NO_INITIAL_AGGRO))
        {
            // Send initial threat
            if (Target->isCreature())
                Target->getAIInterface()->onHostileAction(getUnitCaster());
 
            // Target should enter combat when aura is added on target
            Target->getCombatHandler().takeCombatAction(getUnitCaster());
 
            // Add real threat
            if (Target->getThreatManager().canHaveThreatList())
                Target->getThreatManager().addThreat(getUnitCaster(), 1.f, getSpellInfo(), false, false, this);
        }
    }
 
    // Applying an aura to a flagged target will cause you to get flagged.
    // self casting doesn't flag himself.
    if (Target->isPlayer() && p_caster && p_caster != static_cast<Player*>(Target))
    {
        if (static_cast<Player*>(Target)->isPvpFlagSet())
        {
            if (p_caster->isPlayer() && !p_caster->isPvpFlagSet())
                p_caster->togglePvP();
            else
                p_caster->setPvpFlag();
        }
    }
 
    // remove any auras with same type
    if (getSpellInfo()->custom_BGR_one_buff_on_target > 0)
    {
        Target->removeAllAurasBySpellType(static_cast<SpellTypes>(getSpellInfo()->custom_BGR_one_buff_on_target), m_caster->getGuid(), getSpellInfo()->getId());
    }
 
    uint32_t spellid = 0;
 
    if ((getSpellInfo()->getMechanicsType() == MECHANIC_INVULNARABLE && getSpellInfo()->getId() != 25771) || getSpellInfo()->getId() == 31884)     // Cast spell Forbearance
    {
        if (getSpellInfo()->getId() != 31884)
            spellid = 25771;
 
        if (Target->isPlayer())
        {
            sEventMgr.AddEvent(static_cast<Player*>(Target), &Player::avengingWrath, EVENT_PLAYER_AVENGING_WRATH, 30000, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
            static_cast<Player*>(Target)->m_avengingWrath = false;
        }
    }
    else if (getSpellInfo()->getMechanicsType() == MECHANIC_HEALING && getSpellInfo()->getId() != 11196)  // Cast spell Recently Bandaged
        spellid = 11196;
    else if (getSpellInfo()->getMechanicsType() == MECHANIC_SHIELDED && getSpellInfo()->getId() != 6788)  // Cast spell Weakened Soul
        spellid = 6788;
    else if (getSpellInfo()->getId() == 45438)  // Cast spell Hypothermia
        spellid = 41425;
    else
    {
        switch (getSpellInfo()->getId())
        {
            //SPELL_HASH_HEROISM
            case 23682:
            case 23689:
            case 32182:
            case 32927:
            case 32955:
            case 37471:
            case 39200:
            case 65983:
                spellid = 57723;
                break;
            //SPELL_HASH_BLOODLUST
            case 2825:
            case 6742:
            case 16170:
            case 21049:
            case 23951:
            case 24185:
            case 27689:
            case 28902:
            case 33555:
            case 37067:
            case 37309:
            case 37310:
            case 37472:
            case 37599:
            case 41185:
            case 43578:
            case 45584:
            case 50730:
            case 54516:
            case 65980:
                spellid = 57724;
                break;
            //SPELL_HASH_STEALTH
            case 1784:
            case 1785:
            case 1786:
            case 1787:
            case 8822:
            case 30831:
            case 30991:
            case 31526:
            case 31621:
            case 32199:
            case 32615:
            case 34189:
            case 42347:
            case 42866:
            case 42943:
            case 52188:
            case 58506:
            {
                uint32_t masterOfSubtlety[] =
                {
                    //SPELL_HASH_MASTER_OF_SUBTLETY
                    31221,
                    31222,
                    31223,
                    31665,
                    31666,
                    0
                };
 
                if (Target->hasAurasWithId(masterOfSubtlety))
                    spellid = 31665;
            } break;
            case 62124:
            {
                uint32_t vindication[] =
                {
                    //SPELL_HASH_VINDICATION
                    67,
                    9452,
                    26016,
                    26017,
                    36002,
                    0
                };
 
                if (u_caster)
                {
                    if (const auto* vindicationAur = u_caster->getAuraWithId(vindication))
                    {
                        const uint8_t rank = vindicationAur->getSpellInfo()->hasSpellRanks()
                            ? vindicationAur->getSpellInfo()->getRankInfo()->getRank()
                            : 1;
                        spellid = rank == 2 ? 26017 : 67;
                    }
                }
            } break;
            case 5229:
            {
                uint32_t kingOfTheJungle[] =
                {
                    //SPELL_HASH_KING_OF_THE_JUNGLE
                    48492,
                    48494,
                    48495,
                    51178,
                    51185,
                    0
                };
 
                if (p_caster && (p_caster->getShapeShiftForm() == FORM_BEAR || p_caster->getShapeShiftForm() == FORM_DIREBEAR) &&
                    p_caster->hasAurasWithId(kingOfTheJungle))
                {
                    const auto spellInfo = sSpellMgr.getSpellInfo(51185);
                    if (!spellInfo)
                    {
                        return;
                    }
 
                    Spell* spell = sSpellMgr.newSpell(p_caster, spellInfo, true, nullptr);
 
                    if (const auto* kotjAur = p_caster->getAuraWithId(kingOfTheJungle))
                    {
                        const uint8_t rank = kotjAur->getSpellInfo()->hasSpellRanks()
                            ? kotjAur->getSpellInfo()->getRankInfo()->getRank()
                            : 1;
                        spell->forced_basepoints->set(0, rank * 5);
                    }
                    SpellCastTargets targets(p_caster->getGuid());
                    spell->prepare(&targets);
                }
            } break;
            case 19574:
            {
                if (u_caster != nullptr)
                {
                    uint32_t theBeastWithin[] =
                    {
                        //SPELL_HASH_THE_BEAST_WITHIN
                        34471,
                        34692,
                        38373,
                        50098,
                        70029,
                        0
                    };
 
                    if (u_caster->hasAurasWithId(theBeastWithin))
                        u_caster->castSpell(u_caster, 34471, true);
                }
            } break;
            // SPELL_HASH_RAPID_KILLING
            case 34948:
            case 34949:
            case 35098:
            case 35099:
            {
                if (u_caster != nullptr)
                {
                    uint32_t rapidRecuperation[] =
                    {
                        //SPELL_HASH_RAPID_RECUPERATION
                        53228,
                        53232,
                        56654,
                        58882,
                        58883,
                        64180,
                        64181,
                        0
                    };
 
                    if (u_caster->hasAurasWithId(rapidRecuperation))
                        spellid = 56654;
                }
            } break;
        }
    }
 
    switch (getSpellInfo()->getId())
    {
        // SPELL_HASH_CLEARCASTING:
        case 12536:
        case 16246:
        case 16870:
        case 67210:
        // SPELL_HASH_PRESENCE_OF_MIND:
        case 12043:
        case 29976:
        {
            uint32_t arcanePotency[] =
            {
                //SPELL_HASH_ARCANE_POTENCY
                24544,
                31571,
                31572,
                33421,
                33713,
                57529,
                57531,
                0
            };
            if (const auto* arcPotencyAur = Target->getAuraWithId(arcanePotency))
            {
                const uint8_t rank = arcPotencyAur->getSpellInfo()->hasSpellRanks()
                    ? arcPotencyAur->getSpellInfo()->getRankInfo()->getRank()
                    : 1;
                spellid = rank == 1 ? 57529 : 57531;
            }
        }
        break;
    }
 
    if (spellid)
    {
        const auto spellInfo = sSpellMgr.getSpellInfo(spellid);
        if (!spellInfo)
        {
            return;
        }
 
        Spell* spell = sSpellMgr.newSpell(u_caster, spellInfo, true, nullptr);
 
        uint32_t masterOfSubtlety[] =
        {
            //SPELL_HASH_MASTER_OF_SUBTLETY
            31221,
            31222,
            31223,
            31665,
            31666,
            0
        };
 
        if (spellid == 31665 && Target->hasAurasWithId(masterOfSubtlety))
            spell->forced_basepoints->set(0, Target->getAuraWithId(masterOfSubtlety)->getSpellInfo()->getEffectBasePoints(0));
 
        SpellCastTargets targets(Target->getGuid());
        spell->prepare(&targets);
    }
 
    // avoid map corruption (this is impossible, btw)
    if (Target->GetInstanceID() != m_caster->GetInstanceID())
    {
        return;
    }
 
    Target->addAura(std::move(aur)); // the real spell is added last so the modifier is removed last
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handleHittedEffect()

void Spell::handleHittedEffect	(	const uint64_t	targetGuid,
		uint8_t	effIndex,
		int32_t	effDamage,
		bool	reCheckTarget = `false`
	)

Definition at line 860 of file Spell.cpp.

{
    // If duel has ended before spell cast was finished, do not handle this target and effect
    // but do not cancel entire spell
    // i.e AoE spells can still hit other targets
    if (DuelSpellNoMoreValid())
        return;
 
    if (reCheckTarget)
        _updateTargetPointers(targetGuid);
 
    // TODO: in the future, consider having two damage variables; one for integer and one for float
    damage = effDamage;
 
    // Skip auras here
    // TODO: confirm if instant kill spells should skip combat (atm needed for .kill command)
    if (!getSpellInfo()->doesEffectApplyAura(effIndex) && getUnitCaster() != nullptr && getUnitTarget() != nullptr && getUnitCaster() != getUnitTarget()
        && getSpellInfo()->getEffect(effIndex) != SPELL_EFFECT_INSTANT_KILL)
    {
        if (getUnitCaster()->isFriendlyTo(getUnitTarget()))
        {
            getUnitTarget()->getCombatHandler().takeCombatAction(getUnitCaster(), true);
        }
        else if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NO_INITIAL_AGGRO))
        {
            // Add initial threat
            // Real threat is sent in damage code, in heal code or in apply aura code
            if (getUnitTarget()->isCreature())
                getUnitTarget()->getAIInterface()->onHostileAction(getUnitCaster());
 
            // Target should enter combat when spell lands on target
            getUnitTarget()->getCombatHandler().takeCombatAction(getUnitCaster());
        }
    }
 
    // Clear DamageInfo before effect
    m_targetDamageInfo = DamageInfo();
    m_targetDamageInfo.schoolMask = SchoolMask(getSpellInfo()->getSchoolMask());
    isTargetDamageInfoSet = false;
    isForcedCrit = false;
 
    const auto effectId = getSpellInfo()->getEffect(effIndex);
    if (effectId >= TOTAL_SPELL_EFFECTS)
    {
        sLogger.failure("Spell::handleHittedEffect : Unknown spell effect {} in spell id {}, index {}", effectId, getSpellInfo()->getId(), effIndex);
        return;
    }
 
    sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::handleHittedEffect : Spell effect {}, spell id {}, damage {}", effectId, getSpellInfo()->getId(), damage);
 
    const auto scriptResult = sScriptMgr.callScriptedSpellBeforeSpellEffect(this, effIndex);
 
    // Check if spell is forced to have critical effect on this target
    for (const auto& critGuid : m_critTargets)
    {
        if (critGuid == targetGuid)
        {
            isForcedCrit = true;
            break;
        }
    }
 
    // Call effect handler
    if (scriptResult != SpellScriptExecuteState::EXECUTE_PREVENT)
        (*this.*SpellEffectsHandler[effectId])(effIndex);
 
    sScriptMgr.callScriptedSpellAfterSpellEffect(this, effIndex);
 
    // Create proc events
    if (isTargetDamageInfoSet)
    {
        // Add the DamageInfo to target vector if it was set
        for (auto& uniqueTarget : m_uniqueHittedTargets)
        {
            if (uniqueTarget.first == targetGuid)
                uniqueTarget.second = m_targetDamageInfo;
        }
    }
 
    // Check if target's procs have been handled in spell effects
    // If not, they will be processed in Spell::finish
    // Caster procs are also handled in Spell::finish
    if (m_targetDamageInfo.victimProcFlags != PROC_NULL)
        m_doneTargetProcs.insert(targetGuid);
 
    if (m_uniqueHittedTargets.size() == 1)
    {
        // If spell has only this target, use full DamageInfo for caster's DamageInfo
        if (isTargetDamageInfoSet)
            m_casterDamageInfo = m_targetDamageInfo;
    }
    else
    {
        // If spell has multiple targets, just check if the spell critted for this target
        if (m_targetDamageInfo.isCritical)
            m_casterDamageInfo.isCritical = true;
    }
 
    // Legacy script hook
    DoAfterHandleEffect(getUnitTarget(), effIndex);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handleHittedTarget()

void Spell::handleHittedTarget	(	const uint64_t	targetGuid,
		uint8_t	effIndex
	)

Definition at line 808 of file Spell.cpp.

{
    const auto travelTime = _getSpellTravelTimeForTarget(targetGuid);
    if (travelTime < 0)
        return;
 
    _updateTargetPointers(targetGuid);
    const auto effDamage = calculateEffect(effIndex);
 
    // Enter combat or keep combat alive if spell had at least one target that was either
    // a) hostile
    // b) friendly who was in combat
    // TODO: confirm if instant kill spells should skip combat (atm needed for .kill command)
    if (getUnitCaster() != nullptr && getUnitTarget() != nullptr && getUnitCaster()->getGuid() != getUnitTarget()->getGuid()
        && getSpellInfo()->getEffect(effIndex) != SPELL_EFFECT_INSTANT_KILL)
    {
        // Combat is applied instantly to caster if spell had cast time and target is hostile
        // Instant spells on hostile targets and all spells on friendly targets will have combat delayed
        if (getUnitCaster()->isFriendlyTo(getUnitTarget()))
            getUnitCaster()->getCombatHandler().onFriendlyAction(getUnitTarget());
        else if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NO_INITIAL_AGGRO))
            getUnitCaster()->getCombatHandler().onHostileAction(getUnitTarget(), getFullCastTime() > 0);
    }
 
    // If effect applies an aura, create it instantly but add it later to target
    if (getSpellInfo()->doesEffectApplyAura(effIndex))
    {
        handleHittedEffect(targetGuid, effIndex, effDamage);
 
        // Add travel time to aura
        auto itr = m_pendingAuras.find(targetGuid);
        if (itr != m_pendingAuras.end())
            itr->second.travelTime = Util::float2int32(travelTime);
 
        return;
    }
 
    if (travelTime == 0.0f)
    {
        handleHittedEffect(targetGuid, effIndex, effDamage);
    }
    else
    {
        HitSpellEffect hitEffect;
        hitEffect.damage = effDamage;
        hitEffect.effIndex = effIndex;
        hitEffect.travelTime = Util::float2int32(travelTime);
 
        m_hitEffects.insert(std::make_pair(targetGuid, hitEffect));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handleMissedEffect()

void Spell::handleMissedEffect	(	SpellTargetMod const	missedTarget,
		bool	reCheckTarget = `false`
	)

Definition at line 1046 of file Spell.cpp.

{
    if (reCheckTarget)
        _updateTargetPointers(missedTarget.targetGuid);
 
    // Spell was not reflected and it did not hit target
    if (getUnitTarget() != nullptr)
    {
        if (getUnitCaster() != nullptr)
        {
            if (getUnitCaster()->isFriendlyTo(getUnitTarget()))
            {
                getUnitTarget()->getCombatHandler().takeCombatAction(getUnitCaster(), true);
            }
            else if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NO_INITIAL_AGGRO))
            {
                // Let target creature know that someone tried to cast spell on it
                if (getUnitTarget()->isCreature())
                    getUnitTarget()->getAIInterface()->onHostileAction(getUnitCaster());
 
                // Target should enter combat when spell lands on target
                getUnitTarget()->getCombatHandler().takeCombatAction(getUnitCaster());
            }
        }
 
        // Call scripted after spell missed hook
        sScriptMgr.callScriptedSpellAfterMiss(this, getUnitTarget());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handleMissedTarget()

void Spell::handleMissedTarget ( SpellTargetMod const missedTarget )

Definition at line 962 of file Spell.cpp.

{
    // No need to handle this target if it was in evade mode
    if (missedTarget.hitResult == SPELL_DID_HIT_EVADE)
        return;
 
    const auto didReflect = missedTarget.hitResult == SPELL_DID_HIT_REFLECT && missedTarget.extendedHitResult == SPELL_DID_HIT_SUCCESS;
 
    auto travelTime = _getSpellTravelTimeForTarget(missedTarget.targetGuid);
    if (travelTime < 0)
        return;
 
    _updateTargetPointers(missedTarget.targetGuid);
 
    // Enter combat or keep combat alive if spell had at least one target that was either
    // a) hostile
    // b) friendly who was in combat
    if (getUnitCaster() != nullptr && getUnitTarget() != nullptr)
    {
        // Combat is applied instantly to caster if spell had cast time and target is hostile
        // Instant spells on hostile targets and all spells on friendly targets will have combat delayed
        if (getUnitCaster()->isFriendlyTo(getUnitTarget()))
            getUnitCaster()->getCombatHandler().onFriendlyAction(getUnitTarget());
        else if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NO_INITIAL_AGGRO))
            getUnitCaster()->getCombatHandler().onHostileAction(getUnitTarget(), getFullCastTime() > 0);
    }
 
    // If there is no distance between caster and target, handle effect instantly
    if (travelTime == 0.0f)
    {
        if (didReflect)
        {
            const auto guid = m_caster->getGuid();
            _updateTargetPointers(guid);
 
            // Process each effect from the spell on the original caster
            for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (getSpellInfo()->getEffect(i) != 0)
                    handleHittedEffect(guid, i, calculateEffect(i));
            }
        }
        else
        {
            // Spell was not reflected and it did not hit target
            handleMissedEffect(missedTarget);
        }
    }
    else
    {
        if (didReflect)
        {
            const auto guid = m_caster->getGuid();
            _updateTargetPointers(guid);
 
            // Reflected projectiles move back 4x faster
            travelTime *= 1.25f;
 
            // Process each effect from the spell on the original caster
            for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
            {
                if (getSpellInfo()->getEffect(i) != 0)
                {
                    HitSpellEffect hitEffect;
                    hitEffect.damage = calculateEffect(i);
                    hitEffect.effIndex = i;
                    hitEffect.travelTime = Util::float2int32(travelTime);
 
                    m_hitEffects.insert(std::make_pair(guid, hitEffect));
                }
            }
        }
        else
        {
            // Spell was not reflected and it did not hit target
            MissSpellEffect missEffect;
            missEffect.missInfo = missedTarget;
            missEffect.travelTime = Util::float2int32(travelTime);
 
            m_missEffects.insert(std::make_pair(missedTarget.targetGuid, missEffect));
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleTargetNoObject()

void Spell::HandleTargetNoObject ( )

Definition at line 3057 of file Spell.Legacy.cpp.

{
    float dist = 3;
    float newx = m_caster->GetPositionX() + cosf(m_caster->GetOrientation()) * dist;
    float newy = m_caster->GetPositionY() + sinf(m_caster->GetOrientation()) * dist;
    float newz = m_caster->GetPositionZ();
 
    //clamp Z
    newz = m_caster->getMapHeight(LocationVector(newx, newy, newz));
 
    bool isInLOS = m_caster->IsWithinLOS(LocationVector(newx, newy, newz));
    //if not in line of sight, or too far away we summon inside caster
    if (fabs(newz - m_caster->GetPositionZ()) > 10 || !isInLOS)
    {
        newx = m_caster->GetPositionX();
        newy = m_caster->GetPositionY();
        newz = m_caster->GetPositionZ();
    }
 
    m_targets.addTargetMask(TARGET_FLAG_DEST_LOCATION);
    m_targets.setDestination(LocationVector(newx, newy, newz));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HandleTeleport()

void Spell::HandleTeleport	(	LocationVector	position,
		uint32_t	mapid,
		Unit *	Target
	)

Definition at line 2674 of file Spell.Legacy.cpp.

{
    if (Target->isPlayer())
    {
        Player* pTarget = static_cast<Player*>(Target);
        pTarget->eventAttackStop();
        pTarget->setTargetGuid(0);
 
        // We use a teleport event on this one. Reason being because of UpdateCellActivity,
        // the game object set of the updater thread WILL Get messed up if we teleport from a gameobject
        // caster.
 
        if (!sEventMgr.HasEvent(pTarget, EVENT_PLAYER_TELEPORT))
        {
            sEventMgr.AddEvent(pTarget, &Player::eventTeleport, mapid, pos, uint32_t(0), EVENT_PLAYER_TELEPORT, 1, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
        }
    }
    else
    {
        if (mapid != Target->GetMapId())
        {
            sLogger.failure("Tried to teleport a Creature to another map.");
            return;
        }
 
        WorldPacket data(SMSG_MONSTER_MOVE, 50);
 
        data << Target->GetNewGUID();
        data << uint8_t(0);
        data << Target->GetPositionX();
        data << Target->GetPositionY();
        data << Target->GetPositionZ();
        data << Util::getMSTime();
        data << uint8_t(0x00);
        data << uint32_t(256);
        data << uint32_t(1);
        data << uint32_t(1);
        data << float(pos.x);
        data << float(pos.y);
        data << float(pos.z);
 
        Target->sendMessageToSet(&data, true);
        Target->SetPosition(pos.x, pos.y, pos.z, pos.o);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasAttribute()

bool Spell::hasAttribute ( SpellAttributes _attribute ) const

Definition at line 5794 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributes() & _attribute) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasAttributeEx()

bool Spell::hasAttributeEx ( SpellAttributesEx _attribute ) const

Definition at line 5799 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesEx() & _attribute) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasAttributeExB()

bool Spell::hasAttributeExB ( SpellAttributesExB _attribute ) const

Definition at line 5804 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesExB() & _attribute) != 0;
}

Here is the call graph for this function:

◆ hasAttributeExC()

bool Spell::hasAttributeExC ( SpellAttributesExC _attribute ) const

Definition at line 5809 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesExC() & _attribute) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hasAttributeExD()

bool Spell::hasAttributeExD ( SpellAttributesExD _attribute ) const

Definition at line 5814 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesExD() & _attribute) != 0;
}

Here is the call graph for this function:

◆ hasAttributeExE()

bool Spell::hasAttributeExE ( SpellAttributesExE _attribute ) const

Definition at line 5819 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesExE() & _attribute) != 0;
}

Here is the call graph for this function:

◆ hasAttributeExF()

bool Spell::hasAttributeExF ( SpellAttributesExF _attribute ) const

Definition at line 5824 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesExF() & _attribute) != 0;
}

Here is the call graph for this function:

◆ hasAttributeExG()

bool Spell::hasAttributeExG ( SpellAttributesExG _attribute ) const

Definition at line 5829 of file Spell.cpp.

{
    return (getSpellInfo()->getAttributesExG() & _attribute) != 0;
}

Here is the call graph for this function:

◆ hasTarget()

bool Spell::hasTarget	(	const uint64_t &	_guid,
		std::vector< uint64_t > *	tmpGuidMap
	)

Definition at line 5666 of file Spell.cpp.

{
    for (const uint64_t& guid : *tmpGuidMap)
        if (guid == _guid)
            return true;
 
    for (const auto target: m_missedTargets)
        if (target.targetGuid == _guid)
            return true;
 
    return false;
}

◆ InitProtoOverride()

void Spell::InitProtoOverride ( )

Definition at line 1675 of file Spell.Legacy.cpp.

{
    if (m_spellInfo_override != nullptr)
        return;
    m_spellInfo_override = sSpellMgr.getSpellInfo(getSpellInfo()->getId());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsAspect()

bool Spell::IsAspect ( )

Definition at line 1630 of file Spell.Legacy.cpp.

{
    switch (getSpellInfo()->getId())
    {
        case 2596:
        case 5118:
        case 14320:
        case 13159:
        case 13161:
        case 20190:
        case 20043:
        case 14322:
        case 14321:
        case 13163:
        case 14319:
        case 14318:
        case 13165:
            return true;
        default:
            return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsInvisibilitySpell()

bool Spell::IsInvisibilitySpell ( )

Definition at line 93 of file Spell.Legacy.cpp.

{
    //check if aura name is some invisibility aura
    if (getSpellInfo()->getEffectApplyAuraName(0) == SPELL_AURA_MOD_INVISIBILITY || getSpellInfo()->getEffectApplyAuraName(1) == SPELL_AURA_MOD_INVISIBILITY || getSpellInfo()->getEffectApplyAuraName(2) == SPELL_AURA_MOD_INVISIBILITY)
        return true;
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsSeal()

bool Spell::IsSeal ( )

Definition at line 1653 of file Spell.Legacy.cpp.

{
    switch (getSpellInfo()->getId())
    {
        case 13903:
        case 17177:
        case 20154:
        case 20164:
        case 20165:
        case 20166:
        case 20375:
        case 21084:
        case 31801:
        case 31892:
        case 53720:
        case 53736:
            return true;
        default:
            return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsStealthSpell()

bool Spell::IsStealthSpell ( )

Definition at line 84 of file Spell.Legacy.cpp.

{
    //check if aura name is some stealth aura
    if (getSpellInfo()->getEffectApplyAuraName(0) == SPELL_AURA_MOD_STEALTH || getSpellInfo()->getEffectApplyAuraName(1) == SPELL_AURA_MOD_STEALTH || getSpellInfo()->getEffectApplyAuraName(2) == SPELL_AURA_MOD_STEALTH)
        return true;
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare()

SpellCastResult Spell::prepare ( SpellCastTargets * targets )

Definition at line 255 of file Spell.cpp.

{
    if (!m_caster->IsInWorld())
    {
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Object {} is casting spell ID {} while not in world", std::to_string(m_caster->getGuid()), getSpellInfo()->getId());
        delete this;
        return SPELL_FAILED_DONT_REPORT;
    }
 
    if (p_caster != nullptr)
    {
        // Call Lua script hook
        if (!sHookInterface.OnCastSpell(p_caster, getSpellInfo(), this))
        {
            p_caster->addGarbageSpell(this);
            return SPELL_FAILED_UNKNOWN;
        }
 
        //\ todo: convert this hack to spell script
        if (p_caster->m_cannibalize)
        {
            sEventMgr.RemoveEvents(p_caster, EVENT_CANNIBALIZE);
            p_caster->setEmoteState(EMOTE_ONESHOT_NONE);
            p_caster->m_cannibalize = false;
        }
    }
 
    // Check if spell is disabled
    if (sSpellMgr.isSpellDisabled(getSpellInfo()->getId()))
    {
        sendCastResult(m_triggeredSpell ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_SPELL_UNAVAILABLE);
        finish(false);
        return m_triggeredSpell ? SPELL_FAILED_DONT_REPORT : SPELL_FAILED_SPELL_UNAVAILABLE;
    }
 
    // Check if caster is casting another spell
    if (!m_triggeredSpell && m_caster->isCastingSpell(true, true))
    {
        sendCastResult(SPELL_FAILED_SPELL_IN_PROGRESS);
        finish(false);
        return SPELL_FAILED_SPELL_IN_PROGRESS;
    }
 
    m_spellState = SPELL_STATE_PREPARING;
    m_targets = *targets;
 
    // Set casting position
    m_castPositionX = m_caster->GetPositionX();
    m_castPositionY = m_caster->GetPositionY();
    m_castPositionZ = m_caster->GetPositionZ();
    m_castPositionO = m_caster->GetOrientation();
 
    // Initialize spell cast time
    m_castTime = 0;
    if (!(m_triggeredByAura != nullptr || m_triggeredSpell && (getSpellInfo()->getManaCost() > 0 || getSpellInfo()->getManaCostPercentage() > 0)))
    {
        m_castTime = static_cast<int32_t>(GetCastTime(sSpellCastTimesStore.lookupEntry(getSpellInfo()->getCastingTimeIndex())));
        if (m_castTime > 0 && u_caster != nullptr)
        {
            // Apply cast time modifiers
            u_caster->applySpellModifiers(SPELLMOD_CAST_TIME, &m_castTime, getSpellInfo(), this);
 
            // Apply haste modifier to non-tradeskill spells
            if (!(getSpellInfo()->getAttributes() & (ATTRIBUTES_ABILITY | ATTRIBUTES_TRADESPELL)))
            {
                m_castTime = static_cast<int32_t>(m_castTime * u_caster->getModCastSpeed());
            }
            // Apply ranged haste modifier to ranged spells with cast time
            else if (getSpellInfo()->getAttributes() & ATTRIBUTES_RANGED && !getSpellInfo()->isRangedAutoRepeat())
            {
                m_castTime = static_cast<int32_t>(m_castTime * u_caster->getAttackSpeedModifier(RANGED));
            }
 
            // Instant cast if target is in a non-traded trade slot
            if (p_caster != nullptr && p_caster->getTradeData() != nullptr)
            {
                const auto tradeItem = p_caster->getTradeData()->getTargetTradeData()->getTradeItem(TRADE_SLOT_NONTRADED);
                if (tradeItem != nullptr && tradeItem->getGuid() == m_targets.getItemTargetGuid())
                    m_castTime = 0;
            }
        }
    }
 
    // Check for cast time cheat
    if (m_castTime < 0 || (p_caster != nullptr && p_caster->m_cheats.hasCastTimeCheat))
        m_castTime = 0;
 
    // Initialize power cost
    // Spells casted from items should not use any power
    m_powerCost = i_caster != nullptr ? 0 : calculatePowerCost();
 
    // Item spells or triggered spells should not require combo points
    if (m_triggeredSpell || i_caster != nullptr)
        m_requiresCP = false;
 
    _loadInitialTargetPointers();
 
    // Check if spell can be casted
    uint32_t parameter1 = 0, parameter2 = 0;
    cancastresult = canCast(false, &parameter1, &parameter2);
    if (cancastresult != SPELL_CAST_SUCCESS)
    {
        // Triggered spells also need to go through cancast check but they do not pop a error message
        sendCastResult(m_triggeredSpell ? SPELL_FAILED_DONT_REPORT : cancastresult, parameter1, parameter2);
        // Also need to send SMSG_SPELL_FAILED_OTHER, otherwise spell button gets stuck
        SendInterrupted(0);
 
        if (m_triggeredByAura != nullptr)
        {
            sendChannelUpdate(0);
            m_triggeredByAura->removeAura();
        }
 
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL, "Spell::prepare : canCast result {} for spell id {} (refer to SpellFailure.hpp to work out why)", cancastresult, getSpellInfo()->getId());
 
        finish(false);
        return cancastresult;
    }
 
    m_timer = m_castTime;
 
    _loadInitialTargetPointers(true);
 
    if (!m_triggeredSpell || getSpellInfo()->isChanneled())
        m_caster->setCurrentSpell(this);
 
    if (!m_triggeredSpell)
    {
        if (m_timer > 0)
        {
            // Remove stealth here only if spell has cast time
            // Stealth is removed for instant spells in ::cast
            if (p_caster != nullptr)
            {
                if (!(getSpellInfo()->getAttributesEx() & ATTRIBUTESEX_NOT_BREAK_STEALTH))
                    p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_STEALTH);
 
                // Remove Feign Death auras
                p_caster->removeAllAurasByAuraEffect(SPELL_AURA_FEIGN_DEATH);
            }
 
            // Call for scripted at start casting hook
            sScriptMgr.callScriptedSpellAtStartCasting(this);
        }
 
        // Send cast bar
        sendSpellStart();
 
        // Send global cooldown
        if (p_caster != nullptr && !p_caster->m_cheats.hasCastTimeCheat)
            p_caster->addGlobalCooldown(getSpellInfo(), this);
 
        // Handle instant and non-channeled spells instantly. Other spells will be handled in ::update on next tick.
        // First autorepeat casts are actually never casted, only set as current spell. Player::updateAutoRepeatSpell handles the shooting.
        if (m_castTime == 0 && !getSpellInfo()->isChanneled() && !getSpellInfo()->isRangedAutoRepeat())
            castMe(false);
        else
            m_spellState = SPELL_STATE_CASTING;
    }
    else
    {
        castMe(false);
    }
 
    // TODO: for future reference, I removed aurastate removal here if spell had any aurastate set in SpellInfo::CasterAuraState
    // this is not handled anywhere yet -Appled
 
    return cancastresult;
}

Here is the call graph for this function:

◆ removeCastItem()

void Spell::removeCastItem ( )

private

Definition at line 6013 of file Spell.cpp.

{
    if (getItemCaster() == nullptr)
        return;
 
    auto removable = false, chargesUsed = false;
    const auto proto = getItemCaster()->getItemProperties();
 
    for (uint8_t i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
    {
        const auto protoSpell = proto->Spells[i];
        if (protoSpell.Id > 0)
        {
            if (protoSpell.Charges == 0)
                continue;
 
            // Items with negative charges disappear when they reach 0 charges
            if (protoSpell.Charges < 0)
                removable = true;
 
            auto charges = getItemCaster()->getSpellCharges(i);
            if (charges != 0 && protoSpell.Id == getSpellInfo()->getId())
            {
                if (charges > 0)
                    --charges;
                else
                    ++charges;
 
                // If item is not stackable, modify charges
                if (proto->MaxCount == 1)
                    getItemCaster()->setSpellCharges(i, charges);
 
                getItemCaster()->m_isDirty = true;
            }
 
            chargesUsed = charges == 0;
        }
    }
 
    if (removable && chargesUsed)
    {
        // If the item is stacked, remove 1 from the stack
        if (getItemCaster()->getStackCount() > 1)
        {
            getItemCaster()->modStackCount(-1);
            getItemCaster()->m_isDirty = true;
        }
        else
        {
            getItemCaster()->getOwner()->getItemInterface()->SafeFullRemoveItemByGuid(getItemCaster()->getGuid());
        }
 
        i_caster = nullptr;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ removeReagents()

void Spell::removeReagents ( )

private

Definition at line 6069 of file Spell.cpp.

{
    if (p_caster == nullptr)
        return;
 
#if VERSION_STRING >= TBC
    if (!(p_caster->hasUnitFlags(UNIT_FLAG_NO_REAGANT_COST) && getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_REAGENT_REMOVAL))
#endif
    {
        for (uint8_t i = 0; i < MAX_SPELL_REAGENTS; ++i)
        {
            if (getSpellInfo()->getReagent(i) == 0)
                continue;
 
            const auto itemId = static_cast<uint32_t>(getSpellInfo()->getReagent(i));
            p_caster->getItemInterface()->RemoveItemAmt_ProtectPointer(itemId, getSpellInfo()->getReagentCount(i), &i_caster);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ removeUsedSpellModifier()

void Spell::removeUsedSpellModifier ( AuraEffectModifier const * aurEff )

Definition at line 5862 of file Spell.cpp.

{
    for (auto& usedMod : m_usedModifiers)
    {
        // Mark the spell modifier as removed to prevent memory corruption
        if (usedMod.first == aurEff)
        {
            usedMod.second = true;
            break;
        }
    }
 
    // Also, remove the spell modifier from pending auras
    for (auto& pendingAur : m_pendingAuras)
    {
        if (pendingAur.second.aur != nullptr)
            pendingAur.second.aur->removeUsedSpellModifier(aurEff);
    }
}

Here is the call graph for this function:

◆ resetSpellInfoOverride()

void Spell::resetSpellInfoOverride ( )

Definition at line 5834 of file Spell.cpp.

{
    m_spellInfo_override = nullptr;
}

Here is the caller graph for this function:

◆ safeAddMissedTarget()

void Spell::safeAddMissedTarget	(	uint64_t	targetGuid,
		SpellDidHitResult	hitResult,
		SpellDidHitResult	extendedHitResult
	)

private

Definition at line 5775 of file Spell.cpp.

{
    for (const auto& targetMod : m_missedTargets)
    {
        // Check if target is already in the vector
        if (targetMod.targetGuid == targetGuid)
            return;
    }
 
    m_missedTargets.push_back(SpellTargetMod(targetGuid, hitResult, extendedHitResult));
}

Here is the caller graph for this function:

◆ SafeAddTarget()

void Spell::SafeAddTarget	(	std::vector< uint64_t > *	tgt,
		uint64_t	guid
	)

Definition at line 2885 of file Spell.Legacy.cpp.

{
    if (guid == 0)
        return;
 
    for (std::vector<uint64_t>::iterator i = tgt->begin(); i != tgt->end(); ++i)
    {
        if (*i == guid)
        {
            return;
        }
    }
 
    tgt->push_back(guid);
}

Here is the caller graph for this function:

◆ sendCastResult() [1/2]

void Spell::sendCastResult	(	Player *	caster,
		uint8_t	castCount,
		SpellCastResult	result,
		uint32_t	parameter1,
		uint32_t	parameter2
	)

private

Definition at line 5310 of file Spell.cpp.

{
    if (caster == nullptr)
        return;
 
    // Include missing parameters to error messages
    switch (result)
    {
        case SPELL_FAILED_ONLY_SHAPESHIFT:
            if (parameter1 == 0)
                parameter1 = getSpellInfo()->getRequiredShapeShift();
            break;
        case SPELL_FAILED_REQUIRES_AREA:
            if (parameter1 == 0)
            {
#if VERSION_STRING == TBC
                parameter1 = getSpellInfo()->getRequiresAreaId();
#elif VERSION_STRING >= WotLK
                // Send the first area id from areagroup to player
                auto areaGroup = sAreaGroupStore.lookupEntry(static_cast<uint32_t>(getSpellInfo()->getRequiresAreaId()));
                for (const auto& areaId : areaGroup->AreaId)
                {
                    if (areaId != 0)
                    {
                        parameter1 = areaId;
                        break;
                    }
                }
#endif
            } break;
        case SPELL_FAILED_EQUIPPED_ITEM_CLASS:
        case SPELL_FAILED_EQUIPPED_ITEM_CLASS_MAINHAND:
        case SPELL_FAILED_EQUIPPED_ITEM_CLASS_OFFHAND:
            if (parameter1 == 0 && parameter2 == 0)
            {
                parameter1 = static_cast<uint32_t>(getSpellInfo()->getEquippedItemClass());
                parameter2 = static_cast<uint32_t>(getSpellInfo()->getEquippedItemSubClass());
            } break;
#if VERSION_STRING >= TBC
        case SPELL_FAILED_REAGENTS:
            if (parameter1 == 0)
            {
                for (uint8_t i = 0; i < MAX_SPELL_REAGENTS; ++i)
                {
                    if (getSpellInfo()->getReagent(i) == 0)
                        continue;
 
                    const auto itemId = static_cast<uint32_t>(getSpellInfo()->getReagent(i));
                    if (!caster->hasItem(itemId, getSpellInfo()->getReagentCount(i)))
                    {
                        parameter1 = itemId;
                        break;
                    }
                }
            } break;
        case SPELL_FAILED_TOTEMS:
            if (parameter1 == 0)
            {
                for (uint8_t i = 0; i < MAX_SPELL_TOTEMS; ++i)
                {
                    if (getSpellInfo()->getTotem(i) == 0)
                        continue;
                    if (!caster->hasItem(getSpellInfo()->getTotem(i)))
                    {
                        parameter1 = getSpellInfo()->getTotem(i);
                        break;
                    }
                }
            } break;
        case SPELL_FAILED_TOTEM_CATEGORY:
            if (parameter1 == 0)
            {
                for (uint8_t i = 0; i < MAX_SPELL_TOTEM_CATEGORIES; ++i)
                {
                    if (getSpellInfo()->getTotemCategory(i) == 0)
                        continue;
                    if (!caster->getItemInterface()->hasItemForTotemCategory(getSpellInfo()->getTotemCategory(i)))
                    {
                        parameter1 = getSpellInfo()->getTotemCategory(i);
                        break;
                    }
                }
            } break;
#endif
        case SPELL_FAILED_REQUIRES_SPELL_FOCUS:
            if (parameter1 == 0)
                parameter1 = getSpellInfo()->getRequiresSpellFocus();
            break;
        default:
            break;
    }
 
    caster->sendCastFailedPacket(getSpellInfo()->getId(), result, castCount, parameter1, parameter2);
}

Here is the call graph for this function:

◆ sendCastResult() [2/2]

void Spell::sendCastResult	(	SpellCastResult	result,
		uint32_t	parameter1 = `0`,
		uint32_t	parameter2 = `0`
	)

Definition at line 4552 of file Spell.cpp.

{
    if (result == SPELL_CAST_SUCCESS)
        return;
 
    SetSpellFailed();
 
    if (!m_caster->IsInWorld())
        return;
 
    Player* plr = p_caster;
    if (plr == nullptr && u_caster != nullptr)
    {
        plr = u_caster->m_redirectSpellPackets;
 
        if (plr == nullptr && getUnitCaster()->isVehicle())
            plr = getUnitCaster()->getPlayerOwner();
    }
 
    if (plr == nullptr)
        return;
 
    sendCastResult(plr, 0, result, parameter1, parameter2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sendChannelStart()

void Spell::sendChannelStart ( const uint32_t duration )

private

Definition at line 5273 of file Spell.cpp.

{
    m_caster->sendMessageToSet(MsgChannelStart(m_caster->GetNewGUID(), getSpellInfo()->getId(), duration).serialise().get(), true);
 
    Object const* channelTarget = nullptr;
    if (!m_uniqueHittedTargets.empty())
    {
        // Select first target from uniqueHittedTargets
        // brief: the channel target is properly set in SpellEffects.cpp for persistent dynamic objects
        for (const auto& targetGuid : m_uniqueHittedTargets)
        {
            const auto targetUnit = m_caster->getWorldMapUnit(targetGuid.first);
            if (targetUnit != nullptr)
            {
                channelTarget = targetUnit;
                break;
            }
 
            const auto objTarget = m_caster->getWorldMapGameObject(targetGuid.first);
            if (objTarget != nullptr)
            {
                channelTarget = objTarget;
                break;
            }
        }
    }
 
    if (u_caster != nullptr)
    {
        u_caster->setChannelSpellId(getSpellInfo()->getId());
        if (channelTarget != nullptr)
            u_caster->setChannelObjectGuid(channelTarget->getGuid());
    }
 
    m_timer = duration;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sendChannelUpdate()

void Spell::sendChannelUpdate	(	const uint32_t	time,
		const uint32_t	diff = `0`
	)

Definition at line 4577 of file Spell.cpp.

{
    if (time == 0)
    {
        if (u_caster != nullptr)
        {
            const auto channelGuid = u_caster->getChannelObjectGuid();
 
            // Make sure last periodic tick happens
            if (diff > 0)
            {
                const auto casterGuid = u_caster->getGuid();
                const auto aur = u_caster->getAuraWithIdForGuid(getSpellInfo()->getId(), casterGuid);
                const auto target = u_caster->getWorldMapUnit(channelGuid);
 
                if (aur != nullptr)
                    aur->update(diff, true);
 
                if (target != nullptr)
                {
                    const auto targetAur = target->getAuraWithIdForGuid(getSpellInfo()->getId(), casterGuid);
                    if (targetAur != nullptr)
                        targetAur->update(diff, true);
                }
            }
 
            const auto dynamicObject = u_caster->getWorldMapDynamicObject(WoWGuid::getGuidLowPartFromUInt64(channelGuid));
            if (dynamicObject != nullptr)
                dynamicObject->remove();
 
            u_caster->setChannelObjectGuid(0);
            u_caster->setChannelSpellId(0);
 
            // Remove temporary summons which were created by this channeled spell (i.e Eye of Kilrogg)
            if (p_caster != nullptr && p_caster->getCharmGuid() != 0 && getSpellInfo()->hasEffect(SPELL_EFFECT_SUMMON))
            {
                const auto charmedUnit = p_caster->getWorldMapUnit(p_caster->getCharmGuid());
                if (charmedUnit != nullptr && charmedUnit->getCreatedBySpellId() == getSpellInfo()->getId())
                    p_caster->unPossess();
            }
 
            // Channel ended, remove the aura
            //\ todo: if aura is stackable, need to remove only one stack from aura instead of whole aura!
            u_caster->removeAllAurasByIdForGuid(getSpellInfo()->getId(), u_caster->getGuid());
        }
    }
 
    m_caster->sendMessageToSet(MsgChannelUpdate(m_caster->GetNewGUID(), time).serialise().get(), true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendInterrupted()

void Spell::SendInterrupted ( uint8_t result )

Definition at line 1191 of file Spell.Legacy.cpp.

{
    SetSpellFailed();
 
    if (m_caster == nullptr || !m_caster->IsInWorld())
        return;
 
    // send the failure to pet owner if we're a pet
    Player* plr = p_caster;
    if (plr == nullptr && m_caster->isPet())
    {
        static_cast<Pet*>(m_caster)->sendPetCastFailed(getSpellInfo()->getId(), result);
    }
    else
    {
        if (plr == nullptr && u_caster != nullptr && u_caster->m_redirectSpellPackets != nullptr)
            plr = u_caster->m_redirectSpellPackets;
 
        if (plr != nullptr && plr->isPlayer())
            plr->getSession()->SendPacket(SmsgSpellFailure(m_caster->GetNewGUID(), extra_cast_number, getSpellInfo()->getId(), result).serialise().get());
    }
 
    m_caster->sendMessageToSet(SmsgSpellFailedOther(m_caster->GetNewGUID(), extra_cast_number, getSpellInfo()->getId(), result).serialise().get(), false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendLogExecute()

void Spell::SendLogExecute	(	uint32_t	damage,
		uint64_t &	targetGuid
	)

Definition at line 1176 of file Spell.Legacy.cpp.

{
    WorldPacket data(SMSG_SPELLLOGEXECUTE, 37);
    data << m_caster->GetNewGUID();
    data << getSpellInfo()->getId();
    data << uint32_t(1);
    data << getSpellInfo()->getSpellVisual(0);
    data << uint32_t(1);
    if (m_caster->getGuid() != targetGuid)
        data << targetGuid;
    if (spellDamage)
        data << spellDamage;
    m_caster->sendMessageToSet(&data, true);
}

Here is the call graph for this function:

◆ SendResurrectRequest()

void Spell::SendResurrectRequest ( Player * target )

Definition at line 1216 of file Spell.Legacy.cpp.

{
    bool resurrectionSickness = false;
    std::string casterName;
    if (!m_caster->isPlayer() && m_caster->isCreature())
    {
        casterName = dynamic_cast<Creature*>(m_caster)->GetCreatureProperties()->Name;
 
        if (dynamic_cast<Creature*>(m_caster)->isSpiritHealer())
            resurrectionSickness = true;
    }
 
    bool overrideTimer = false;
    if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_IGNORE_RESURRECTION_TIMER)
        overrideTimer = true;
 
    target->getSession()->SendPacket(SmsgResurrectRequest(m_caster->getGuid(), casterName, resurrectionSickness, overrideTimer, getSpellInfo()->getId()).serialise().get());
    target->setResurrecterGuid(m_caster->getGuid());
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sendSpellGo()

void Spell::sendSpellGo ( )

private

Definition at line 4942 of file Spell.cpp.

{
#if VERSION_STRING == Mop
    if (!m_caster || !m_caster->IsInWorld())
        return;
 
    // If spell has no visuals, it's not channeled and it's triggered, no need to send packet
    if (!(getSpellInfo()->isChanneled() || getSpellInfo()->getSpeed() > 0.0f || getSpellInfo()->getSpellVisual(0) != 0 ||
        getSpellInfo()->getSpellVisual(1) != 0 || (!m_triggeredSpell && m_triggeredByAura == nullptr)))
        return;
 
    ObjectGuid casterGuid = i_caster ? i_caster->getGuid() : m_caster->getGuid();
    ObjectGuid casterUnitGuid = m_caster->getGuid();
    ObjectGuid targetGuid = m_targets.getGameObjectTargetGuid();
    ObjectGuid itemTargetGuid = m_targets.getItemTargetGuid();
    ObjectGuid unkGuid = 0;
    bool hasDestLocation = (m_targets.getTargetMask() & TARGET_FLAG_DEST_LOCATION) && m_targets.getDestination().isSet();
    bool hasSourceLocation = (m_targets.getTargetMask() & TARGET_FLAG_SOURCE_LOCATION) && m_targets.getDestination().isSet();
    bool hasDestUnkByte = m_targets.getTargetMask() & TARGET_FLAG_DEST_LOCATION;
    bool hasTargetString = m_targets.getTargetMask() & TARGET_FLAG_STRING;
    bool hasPredictedHeal = false;
    bool hasPredictedType = false;
    bool hasTargetMask = m_targets.getTargetMask() != 0;
    bool hasCastImmunities = false;
    bool hasCastSchoolImmunities = false;
    bool hasElevation = false;
    bool hasDelayTime = false;
    bool hasVisualChain = false;
    bool hasAmmoInventoryType = false;
    bool hasAmmoDisplayId = false;
    bool hasRunesStateBefore = false;
    bool hasRunesStateAfter = false;
    uint8_t predictedPowerCount = false;
    uint8_t runeCooldownPassedCount = false;
 
    WorldPacket data(SMSG_SPELL_GO, 60);
 
    data.writeBit(casterUnitGuid[2]);
    data.writeBit(1); // hasAmmoDisplayType
    data.writeBit(hasSourceLocation);
    data.writeBit(casterGuid[2]);
 
 
    data.writeBit(casterGuid[6]);
    data.writeBit(!hasDestUnkByte);
    data.writeBit(casterUnitGuid[7]);
    data.writeBits(0, 20); // Extra Target Count
 
    size_t missTypeCountPos = data.bitwpos();
    data.writeBits(0, 25); // Miss Type Count
 
    size_t missCountPos = data.bitwpos();
    data.writeBits(0, 24); // Miss Count
 
    data.writeBit(casterUnitGuid[1]);
    data.writeBit(casterGuid[0]);
    data.writeBits(0, 13); // Unknown bits
 
 
    data.writeBit(casterUnitGuid[5]);
    data.writeBit(0); // Fake bit
    data.writeBit(0); // Fake bit
    data.writeBit(!hasTargetString);
 
    data.writeBit(itemTargetGuid[7]);
    data.writeBit(itemTargetGuid[2]);
    data.writeBit(itemTargetGuid[1]);
    data.writeBit(itemTargetGuid[3]);
    data.writeBit(itemTargetGuid[6]);
    data.writeBit(itemTargetGuid[0]);
    data.writeBit(itemTargetGuid[5]);
    data.writeBit(itemTargetGuid[4]);
 
    data.writeBit(casterGuid[7]);
 
    data.writeBit(targetGuid[0]);
    data.writeBit(targetGuid[6]);
    data.writeBit(targetGuid[5]);
    data.writeBit(targetGuid[7]);
    data.writeBit(targetGuid[4]);
    data.writeBit(targetGuid[2]);
    data.writeBit(targetGuid[3]);
    data.writeBit(targetGuid[1]);
 
    data.writeBit(!hasRunesStateBefore);
    data.writeBits(predictedPowerCount, 21); // predictedPowerCount
    data.writeBit(casterGuid[1]);
    data.writeBit(!hasPredictedType);
    data.writeBit(!hasTargetMask);
    data.writeBit(casterUnitGuid[3]);
 
    data.writeBit(1); // Missing Predict heal
    data.writeBit(0); // hasPowerData
    data.writeBit(1); // has castImmunitiy
    data.writeBit(casterUnitGuid[6]);
    data.writeBit(0); // Fake bit
    data.writeBit(hasVisualChain);
 
    data.writeBit(unkGuid[7]);
    data.writeBit(unkGuid[6]);
    data.writeBit(unkGuid[1]);
    data.writeBit(unkGuid[2]);
    data.writeBit(unkGuid[0]);
    data.writeBit(unkGuid[5]);
    data.writeBit(unkGuid[3]);
    data.writeBit(unkGuid[4]);
 
    data.writeBit(!hasDelayTime);
    data.writeBit(1); // has School Immunities
    data.writeBits(runeCooldownPassedCount, 3); // runeCooldownPassedCount
    data.writeBit(casterUnitGuid[0]);
 
    if (hasTargetMask)
        data.writeBits(m_targets.getTargetMask(), 20);
 
    data.writeBit(!hasElevation);
    data.writeBit(!hasRunesStateAfter);
    data.writeBit(casterGuid[4]);
    data.writeBit(1); // hasAmmodisplayID
    data.writeBit(hasDestLocation);
    data.writeBit(casterGuid[5]);
 
    data.writeBits(0, 24); // Hit Count
 
    data.writeBit(casterUnitGuid[4]);
 
    data.writeBit(casterGuid[3]);
    data.flushBits();
 
    data.WriteByteSeq(targetGuid[5]);
    data.WriteByteSeq(targetGuid[2]);
    data.WriteByteSeq(targetGuid[1]);
    data.WriteByteSeq(targetGuid[6]);
    data.WriteByteSeq(targetGuid[0]);
    data.WriteByteSeq(targetGuid[3]);
    data.WriteByteSeq(targetGuid[4]);
    data.WriteByteSeq(targetGuid[7]);
 
    data.WriteByteSeq(itemTargetGuid[5]);
    data.WriteByteSeq(itemTargetGuid[2]);
    data.WriteByteSeq(itemTargetGuid[0]);
    data.WriteByteSeq(itemTargetGuid[6]);
    data.WriteByteSeq(itemTargetGuid[7]);
    data.WriteByteSeq(itemTargetGuid[3]);
    data.WriteByteSeq(itemTargetGuid[1]);
    data.WriteByteSeq(itemTargetGuid[4]);
 
    data.WriteByteSeq(casterGuid[2]);
 
    data.WriteByteSeq(unkGuid[6]);
    data.WriteByteSeq(unkGuid[2]);
    data.WriteByteSeq(unkGuid[7]);
    data.WriteByteSeq(unkGuid[1]);
    data.WriteByteSeq(unkGuid[4]);
    data.WriteByteSeq(unkGuid[3]);
    data.WriteByteSeq(unkGuid[5]);
    data.WriteByteSeq(unkGuid[0]);
 
 
    data << uint32_t(Util::getMSTime());
 
    data.WriteByteSeq(casterGuid[6]);
    data.WriteByteSeq(casterUnitGuid[7]);
    data.WriteByteSeq(casterGuid[1]);
 
    if (hasVisualChain)
    {
        data << uint32_t(0);
        data << uint32_t(0);
    }
 
    data << uint32_t(0);
 
    data.WriteByteSeq(casterUnitGuid[6]);
 
    if (hasPredictedType)
        data << uint8_t(0);
 
    data.WriteByteSeq(casterGuid[4]);
    data.WriteByteSeq(casterUnitGuid[1]);
 
    data.WriteByteSeq(casterGuid[0]);
 
    data << uint8_t(0);
 
    data.WriteByteSeq(casterGuid[5]);
    data.WriteByteSeq(casterUnitGuid[2]);
    data.WriteByteSeq(casterGuid[3]);
    data.WriteByteSeq(casterUnitGuid[5]);
 
    data << uint32_t(m_spellInfo->getId());
 
    data.WriteByteSeq(casterUnitGuid[0]);
    data.WriteByteSeq(casterUnitGuid[3]);
    data.WriteByteSeq(casterUnitGuid[4]);
    data.WriteByteSeq(casterGuid[7]);
 
    m_caster->sendMessageToSet(&data, true);
#else
    if (!m_caster->IsInWorld())
        return;
 
    // If spell has no visuals and it's not channeled and it's triggered, no need to send packet
    if (!(getSpellInfo()->isChanneled() || getSpellInfo()->getSpeed() > 0.0f || getSpellInfo()->getSpellVisual(0) != 0 ||
        getSpellInfo()->getSpellVisual(1) != 0 || (!m_triggeredSpell && m_triggeredByAura == nullptr)))
        return;
 
    // Size should be enough
    WorldPacket data(SMSG_SPELL_GO, 60);
 
    // Set cast flags
    uint32_t castFlags = 0;
    if (GetType() == SPELL_DMG_TYPE_RANGED)
        castFlags |= SPELL_PACKET_FLAGS_RANGED;
 
    if (i_caster != nullptr)
        castFlags |= SPELL_PACKET_FLAGS_ITEM_CASTER;
 
    if (!m_missedTargets.empty())
        castFlags |= SPELL_PACKET_FLAGS_EXTRA_MESSAGE;
 
#if VERSION_STRING >= WotLK
    if (m_missileTravelTime != 0)
        castFlags |= SPELL_PACKET_FLAGS_UPDATE_MISSILE;
 
    // Rune update
    uint8_t currentRunes = 0;
    if (p_caster != nullptr && p_caster->isClassDeathKnight())
    {
        // Get current available runes in bitmask
        currentRunes = static_cast<DeathKnight*>(p_caster)->GetRuneFlags();
 
        if (getSpellInfo()->getRuneCostID() > 0 || currentRunes != m_rune_avail_before)
            castFlags |= SPELL_PACKET_FLAGS_RUNE_UPDATE | SPELL_PACKET_FLAGS_UNK40000;
    }
 
    // Power update for players and their summons
    if ((p_caster != nullptr || (u_caster != nullptr && u_caster->getPlayerOwner() != nullptr)) &&
        getSpellInfo()->getPowerType() != POWER_TYPE_HEALTH)
        castFlags |= SPELL_PACKET_FLAGS_POWER_UPDATE;
#endif
 
    if (i_caster != nullptr)
        data << i_caster->GetNewGUID();
    else
        data << m_caster->GetNewGUID();
 
    data << m_caster->GetNewGUID();
 
#if VERSION_STRING >= WotLK
    data << uint8_t(extra_cast_number);
    data << uint32_t(getSpellInfo()->getId());
    data << uint32_t(castFlags);
#else
    data << uint32_t(getSpellInfo()->getId());
    data << uint16_t(castFlags);
#endif
#if VERSION_STRING >= Cata
    data << uint32_t(m_timer);
#endif
#if VERSION_STRING != Classic
    data << uint32_t(Util::getMSTime());
#endif
 
    // Add hitted targets
    data << uint8_t(m_uniqueHittedTargets.size());
    for (const auto& uniqueTarget : m_uniqueHittedTargets)
    {
        data << uint64_t(uniqueTarget.first);
    }
 
#if VERSION_STRING >= WotLK
    // Add missed targets
    if (castFlags & SPELL_PACKET_FLAGS_EXTRA_MESSAGE)
    {
        data << uint8_t(m_missedTargets.size());
        writeSpellMissedTargets(&data);
    }
    else
    {
        data << uint8_t(0);
    }
 
    m_targets.write(data);
 
 
    if (castFlags & SPELL_PACKET_FLAGS_POWER_UPDATE && u_caster != nullptr)
        data << uint32_t(u_caster->getPower(getSpellInfo()->getPowerType()));
#else
    data << uint8_t(m_missedTargets.size());
 
    if (castFlags & SPELL_PACKET_FLAGS_EXTRA_MESSAGE)
        writeSpellMissedTargets(&data);
 
    m_targets.write(data);
#endif
 
    if (castFlags & SPELL_PACKET_FLAGS_RANGED)
        writeProjectileDataToPacket(&data);
 
#if VERSION_STRING >= WotLK
    //data order depending on flags : 0x800, 0x200000, 0x20000, 0x20, 0x80000, 0x40 (this is not spellgoflag but seems to be from spellentry or packet..)
    //.text:00401110                 mov     eax, [ecx+14h] -> them
    //.text:00401115                 cmp     eax, [ecx+10h] -> us
    if (castFlags & SPELL_PACKET_FLAGS_RUNE_UPDATE)
    {
        data << uint8_t(m_rune_avail_before);
        data << uint8_t(currentRunes);
        for (uint8_t i = 0; i < MAX_RUNES; ++i)
        {
            const uint8_t runeMask = 1U << i;
            if ((runeMask & m_rune_avail_before) != (runeMask & currentRunes))
                data << uint8_t(0); // Value of the rune converted into byte. We just think it is 0 but maybe it is not
        }
    }
 
    if (castFlags & SPELL_PACKET_FLAGS_UPDATE_MISSILE)
    {
        data << float(m_missilePitch);
        data << uint32_t(m_missileTravelTime);
    }
 
    // Some spells require this
    if (m_targets.hasDestination())
        data << uint8_t(0);
#endif
 
    m_caster->sendMessageToSet(&data, true);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sendSpellStart()

void Spell::sendSpellStart ( )

private

Definition at line 4627 of file Spell.cpp.

{
#if VERSION_STRING == Mop
    if (!m_caster || !m_caster->IsInWorld())
        return;
 
    // If spell has no visuals, it's not channeled and it's triggered, no need to send packet
    if (!(getSpellInfo()->isChanneled() || getSpellInfo()->getSpeed() > 0.0f || getSpellInfo()->getSpellVisual(0) != 0 ||
        getSpellInfo()->getSpellVisual(1) != 0 || (!m_triggeredSpell && m_triggeredByAura == nullptr)))
        return;
 
    ObjectGuid casterGuid = i_caster ? i_caster ->getGuid() : m_caster->getGuid();
    ObjectGuid casterUnitGuid = m_caster->getGuid();
    ObjectGuid targetGuid = m_targets.getGameObjectTargetGuid();
    ObjectGuid itemTargetGuid = m_targets.getItemTargetGuid();
    ObjectGuid unkGuid = 0;
    bool hasDestLocation = (m_targets.getTargetMask() & TARGET_FLAG_DEST_LOCATION) && m_targets.getDestination().isSet();
    bool hasSourceLocation = (m_targets.getTargetMask() & TARGET_FLAG_SOURCE_LOCATION) && m_targets.getDestination().isSet();
    bool hasTargetString = false;// m_targets.getTargetMask()& TARGET_FLAG_STRING;
    bool hasPredictedHeal = false;
    bool hasPredictedType = false;
    bool hasTargetMask = m_targets.getTargetMask() != 0;
    bool hasCastImmunities = false;
    bool hasCastSchoolImmunities = false;
    bool hasElevation = false;
    bool hasVisualChain = false;
    bool hasAmmoInventoryType = false;
    bool hasAmmoDisplayId = false;
    uint8_t runeCooldownPassedCount = 0;
    uint8_t predictedPowerCount = 0;
 
    WorldPacket data(SMSG_SPELL_START, 25);
 
    data.writeBits(0, 24); // Miss Count (not used currently in SMSG_SPELL_START)
    data.writeBit(casterGuid[5]);
 
    //for (uint32_t i = 0; i < missCount; ++i)
    //{
    //}
 
    data.writeBit(1); // Unk read int8_t
    data.writeBit(0); // Fake Bit
    data.writeBit(casterUnitGuid[4]);
    data.writeBit(casterGuid[2]);
    data.writeBits(runeCooldownPassedCount, 3); // Rune Cooldown Passed Count
    data.writeBit(casterUnitGuid[2]);
    data.writeBit(casterUnitGuid[6]);
    data.writeBits(0, 25); // MissType Count (not used currently in SMSG_SPELL_START)
    data.writeBits(0, 13); // Unknown Bits
    data.writeBit(casterGuid[4]);
    data.writeBits(0, 24); // Hit Count (not used currently in SMSG_SPELL_START)
    data.writeBit(casterUnitGuid[7]);
 
    //for (uint32_t i = 0; i < hitCount; ++i)
    //{
    //}
 
    data.writeBit(hasSourceLocation);
    data.writeBits(predictedPowerCount, 21);
 
    data.writeBit(itemTargetGuid[3]);
    data.writeBit(itemTargetGuid[0]);
    data.writeBit(itemTargetGuid[1]);
    data.writeBit(itemTargetGuid[7]);
    data.writeBit(itemTargetGuid[2]);
    data.writeBit(itemTargetGuid[6]);
    data.writeBit(itemTargetGuid[4]);
    data.writeBit(itemTargetGuid[5]);
 
    data.writeBit(!hasElevation);
    data.writeBit(!hasTargetString);
    data.writeBit(!hasAmmoInventoryType);
    data.writeBit(hasDestLocation);
    data.writeBit(1); // Unk Read32
    data.writeBit(casterGuid[3]);
 
    if (hasDestLocation)
    {
 
    }
 
    data.writeBit(!hasAmmoDisplayId);
 
    if (hasSourceLocation)
    {
 
    }
 
    data.writeBit(0); // Fake Bit
    data.writeBit(casterGuid[6]);
 
    data.writeBit(unkGuid[2]);
    data.writeBit(unkGuid[1]);
    data.writeBit(unkGuid[7]);
    data.writeBit(unkGuid[6]);
    data.writeBit(unkGuid[0]);
    data.writeBit(unkGuid[5]);
    data.writeBit(unkGuid[3]);
    data.writeBit(unkGuid[4]);
 
    data.writeBit(!hasTargetMask);
 
    if (hasTargetMask)
        data.writeBits(m_targets.getTargetMask(), 20);
 
    data.writeBit(casterGuid[1]);
    data.writeBit(!hasPredictedHeal);
    data.writeBit(1); // Unk read int8_t
    data.writeBit(!hasCastSchoolImmunities);
    data.writeBit(casterUnitGuid[5]);
    data.writeBit(0); // Fake Bit
    data.writeBits(0, 20); // Extra Target Count (not used currently in SMSG_SPELL_START)
 
    //for (uint32_t i = 0; i < extraTargetCount; ++i)
    //{
    //}
 
    data.writeBit(targetGuid[1]);
    data.writeBit(targetGuid[4]);
    data.writeBit(targetGuid[6]);
    data.writeBit(targetGuid[7]);
    data.writeBit(targetGuid[5]);
    data.writeBit(targetGuid[3]);
    data.writeBit(targetGuid[0]);
    data.writeBit(targetGuid[2]);
 
    data.writeBit(casterGuid[0]);
    data.writeBit(casterUnitGuid[3]);
    data.writeBit(1); // Unk uint8_t
 
 
 
    //for (uint32_t i = 0; i < missTypeCount; ++i)
    //{
    //}
 
    data.writeBit(!hasCastImmunities);
    data.writeBit(casterUnitGuid[1]);
    data.writeBit(hasVisualChain);
    data.writeBit(casterGuid[7]);
    data.writeBit(!hasPredictedType);
    data.writeBit(casterUnitGuid[0]);
 
    data.flushBits();
 
    data.WriteByteSeq(itemTargetGuid[1]);
    data.WriteByteSeq(itemTargetGuid[7]);
    data.WriteByteSeq(itemTargetGuid[6]);
    data.WriteByteSeq(itemTargetGuid[0]);
    data.WriteByteSeq(itemTargetGuid[4]);
    data.WriteByteSeq(itemTargetGuid[2]);
    data.WriteByteSeq(itemTargetGuid[3]);
    data.WriteByteSeq(itemTargetGuid[5]);
 
    //for (uint32_t i = 0; i < hitCount; ++i)
    //{
    //}
 
    data.WriteByteSeq(targetGuid[4]);
    data.WriteByteSeq(targetGuid[5]);
    data.WriteByteSeq(targetGuid[1]);
    data.WriteByteSeq(targetGuid[7]);
    data.WriteByteSeq(targetGuid[6]);
    data.WriteByteSeq(targetGuid[3]);
    data.WriteByteSeq(targetGuid[2]);
    data.WriteByteSeq(targetGuid[0]);
 
    data << uint32_t(m_castTime);
 
    data.WriteByteSeq(unkGuid[4]);
    data.WriteByteSeq(unkGuid[5]);
    data.WriteByteSeq(unkGuid[3]);
    data.WriteByteSeq(unkGuid[2]);
    data.WriteByteSeq(unkGuid[1]);
    data.WriteByteSeq(unkGuid[6]);
    data.WriteByteSeq(unkGuid[7]);
    data.WriteByteSeq(unkGuid[0]);
 
 
 
 
    data.WriteByteSeq(casterGuid[4]);
 
    //for (uint32_t i = 0; i < missCount; ++i)
    //{
    //}
 
    if (hasCastSchoolImmunities)
        data << uint32_t(0);
 
    data.WriteByteSeq(casterGuid[2]);
 
    if (hasCastImmunities)
        data << uint32_t(0);
 
    if (hasVisualChain)
    {
        data << uint32_t(0);
        data << uint32_t(0);
    }
 
 
    data << uint32_t(0);
 
    data.WriteByteSeq(casterGuid[5]);
    data.WriteByteSeq(casterGuid[7]);
    data.WriteByteSeq(casterGuid[1]);
 
    data << uint8_t(1);
 
    data.WriteByteSeq(casterUnitGuid[7]);
    data.WriteByteSeq(casterUnitGuid[0]);
    data.WriteByteSeq(casterGuid[6]);
    data.WriteByteSeq(casterGuid[0]);
    data.WriteByteSeq(casterUnitGuid[1]);
 
    if (hasAmmoInventoryType)
        data << uint8_t(0);
 
    if (hasPredictedHeal)
        data << uint32_t(0);
 
    data.WriteByteSeq(casterUnitGuid[6]);
    data.WriteByteSeq(casterUnitGuid[3]);
 
    data << uint32_t(m_spellInfo->getId());
 
    if (hasAmmoDisplayId)
        data << uint32_t(0);
 
    data.WriteByteSeq(casterUnitGuid[4]);
    data.WriteByteSeq(casterUnitGuid[5]);
    data.WriteByteSeq(casterUnitGuid[2]);
 
 
    if (hasPredictedType)
        data << uint8_t(0);
 
    data.WriteByteSeq(casterGuid[3]);
 
    m_caster->sendMessageToSet(&data, true);
#else
    if (!m_caster->IsInWorld())
        return;
 
    // If spell has no visuals, it's not channeled and it's triggered, no need to send packet
    if (!(getSpellInfo()->isChanneled() || getSpellInfo()->getSpeed() > 0.0f || getSpellInfo()->getSpellVisual(0) != 0 ||
        getSpellInfo()->getSpellVisual(1) != 0 || (!m_triggeredSpell && m_triggeredByAura == nullptr)))
        return;
 
    // Not sure about the size -Appled
    WorldPacket data(SMSG_SPELL_START, 30);
 
    // Set cast flags
    uint32_t castFlags = SPELL_PACKET_FLAGS_DEFAULT;
    if (GetType() == SPELL_DMG_TYPE_RANGED)
        castFlags |= SPELL_PACKET_FLAGS_RANGED;
 
#if VERSION_STRING >= WotLK
    // Power update for players and their summons
    if ((p_caster != nullptr || (u_caster != nullptr && u_caster->getPlayerOwner() != nullptr)) &&
        getSpellInfo()->getPowerType() != POWER_TYPE_HEALTH)
        castFlags |= SPELL_PACKET_FLAGS_POWER_UPDATE;
#endif
 
#if VERSION_STRING >= Cata
    // Health update for healing spells
    ///\ todo: fix me!
    /*for (uint8_t i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if ((m_castTime > 0 && getSpellInfo()->getEffect(i) == SPELL_EFFECT_HEAL) ||
            getSpellInfo()->getEffectApplyAuraName(i) == SPELL_AURA_PERIODIC_HEAL)
        {
            castFlags |= SPELL_PACKET_FLAGS_HEALTH_UPDATE;
            break;
        }
    }*/
#endif
 
    if (i_caster != nullptr)
        data << i_caster->GetNewGUID();
    else
        data << m_caster->GetNewGUID();
    data << m_caster->GetNewGUID();
 
#if VERSION_STRING >= WotLK
    data << uint8_t(extra_cast_number);
    data << uint32_t(getSpellInfo()->getId());
    data << uint32_t(castFlags);
#else
    data << uint32_t(getSpellInfo()->getId());
#if VERSION_STRING != Classic
    data << uint8_t(extra_cast_number);
#endif
    data << uint16_t(castFlags);
#endif
    data << uint32_t(m_timer);
#if VERSION_STRING >= Cata
    data << uint32_t(m_castTime);
#endif
 
    m_targets.write(data);
 
#if VERSION_STRING >= WotLK
    if (castFlags & SPELL_PACKET_FLAGS_POWER_UPDATE && u_caster != nullptr)
        data << uint32_t(u_caster->getPower(getSpellInfo()->getPowerType()));
#endif
 
    if (castFlags & SPELL_PACKET_FLAGS_RANGED)
        writeProjectileDataToPacket(&data);
 
    m_caster->sendMessageToSet(&data, true);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SendTameFailure()

void Spell::SendTameFailure ( uint8_t failure )

Definition at line 1236 of file Spell.Legacy.cpp.

{
    if (p_caster != nullptr)
        p_caster->sendPetTameFailure(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setForceCritOnTarget()

void Spell::setForceCritOnTarget ( Unit const * target )

Definition at line 5902 of file Spell.cpp.

{
    if (target == nullptr || target->getWorldMap() == nullptr)
        return;
 
    m_critTargets.push_back(target->getGuid());
}

Here is the call graph for this function:

◆ setItemCaster()

void Spell::setItemCaster ( Item * itemCaster )

Definition at line 5654 of file Spell.cpp.

{
    i_caster = itemCaster;
}

Here is the caller graph for this function:

◆ SetSpellFailed()

void Spell::SetSpellFailed ( bool failed = true )

Definition at line 2921 of file Spell.Legacy.cpp.

{
    m_Spell_Failed = failed;
}

Here is the caller graph for this function:

◆ setTargetConstraintCreature()

void Spell::setTargetConstraintCreature ( Creature * _creature )

Definition at line 5699 of file Spell.cpp.

5699{ m_targetConstraintCreature = _creature; }

Here is the caller graph for this function:

◆ setTargetConstraintGameObject()

void Spell::setTargetConstraintGameObject ( GameObject * _gameobject )

Definition at line 5702 of file Spell.cpp.

5702{ m_targetConstraintGameObject = _gameobject; }

Here is the caller graph for this function:

◆ setUnitTarget()

void Spell::setUnitTarget ( Unit * _unit )

Definition at line 5681 of file Spell.cpp.

5681{ m_unitTarget = _unit; }

Here is the caller graph for this function:

◆ spellEffectActivateObject()

void Spell::spellEffectActivateObject ( uint8_t effectIndex )

◆ SpellEffectActivateObject()

void Spell::SpellEffectActivateObject ( uint8_t effectIndex )

Definition at line 4796 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster)
        return;
 
    if (!m_gameObjTarget)
    {
        sLogger.failure("Spell {} ({}) effect %hhu not handled because no target was found. ", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
        return;
    }
 
    if (m_gameObjTarget->GetScript())
        m_gameObjTarget->GetScript()->OnActivate(p_caster);
 
    m_gameObjTarget->setDynamicFlags(GO_DYN_FLAG_INTERACTABLE);
 
#if VERSION_STRING < WotLK
    sEventMgr.AddEvent(m_gameObjTarget, &GameObject::setDynamicFlags, static_cast<uint32_t>(0), 0, static_cast<uint32_t>(getDuration()), 1, 0);
#elif VERSION_STRING < Mop
    sEventMgr.AddEvent(m_gameObjTarget, &GameObject::setDynamicFlags, static_cast<uint16_t>(0), 0, static_cast<uint32_t>(getDuration()), 1, 0);
#else
    sEventMgr.AddEvent(dynamic_cast<Object*>(m_gameObjTarget), &Object::setDynamicFlags, static_cast<uint16_t>(0), 0, static_cast<uint32_t>(getDuration()), 1, 0);
#endif
}

Here is the call graph for this function:

◆ spellEffectActivateRunes()

void Spell::spellEffectActivateRunes ( uint8_t effectIndex )

◆ SpellEffectActivateRunes()

void Spell::SpellEffectActivateRunes ( uint8_t effectIndex )

Definition at line 6412 of file SpellEffects.Legacy.cpp.

{
    if (p_caster == nullptr || !p_caster->isClassDeathKnight())
        return;
 
    DeathKnight* dk = static_cast<DeathKnight*>(p_caster);
 
    uint32_t count = damage;
    if (!count)
        count = 1;
 
    for (uint8_t x = 0; x < MAX_RUNES && count; ++x)
    {
        if (dk->GetRuneType(x) == getSpellInfo()->getEffectMiscValue(effectIndex) && dk->GetRuneIsUsed(x))
        {
            dk->ResetRune(x);
            --count;
        }
    }
}

Here is the call graph for this function:

◆ spellEffectActivateSpec()

void Spell::spellEffectActivateSpec ( uint8_t effectIndex )

◆ SpellEffectActivateSpec()

void Spell::SpellEffectActivateSpec ( uint8_t effectIndex )

Definition at line 6190 of file SpellEffects.Legacy.cpp.

{
#ifndef FT_DUAL_SPEC
    return;
#else
    if (p_caster == nullptr)
        return;
 
    if (p_caster->getCombatHandler().isInCombat())
    {
        sendCastResult(SPELL_FAILED_AFFECTING_COMBAT);
        return;
    }
    else if (p_caster->getBattleground())
    {
        if (p_caster->getBattleground()->isArena())
        {
            sendCastResult(SPELL_FAILED_AFFECTING_COMBAT); // does the job
            return;
        }
        else
        {
            if (p_caster->getBattleground()->hasStarted())
                sendCastResult(SPELL_FAILED_AFFECTING_COMBAT); // does the job
        }
    }
 
    // TODO: check if player even have learnt secondary spec
    uint8_t NewSpec = p_caster->m_talentActiveSpec == SPEC_PRIMARY ? SPEC_SECONDARY : SPEC_PRIMARY; // Check if primary spec is on or not
    p_caster->activateTalentSpec(NewSpec);
#endif
}

Here is the call graph for this function:

◆ spellEffectAddComboPoints()

void Spell::spellEffectAddComboPoints ( uint8_t effectIndex )

◆ SpellEffectAddComboPoints()

void Spell::SpellEffectAddComboPoints ( uint8_t effectIndex )

Definition at line 4711 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster)
        return;
 
    p_caster->addComboPoints(p_caster->getTargetGuid(), static_cast<uint8_t>(damage));
}

Here is the call graph for this function:

◆ spellEffectAddExtraAttacks()

void Spell::spellEffectAddExtraAttacks ( uint8_t effectIndex )

◆ SpellEffectAddExtraAttacks()

void Spell::SpellEffectAddExtraAttacks ( uint8_t effectIndex )

Definition at line 2475 of file SpellEffects.Legacy.cpp.

{
    if (!u_caster)
        return;
    u_caster->m_extraAttacks += damage;
}

◆ spellEffectAddFarsight()

void Spell::spellEffectAddFarsight ( uint8_t effectIndex )

◆ SpellEffectAddFarsight()

void Spell::SpellEffectAddFarsight ( uint8_t effectIndex )

Definition at line 4571 of file SpellEffects.Legacy.cpp.

{
    if (p_caster == nullptr)
        return;
 
    auto lv = m_targets.getDestination();
    if (!lv.isSet())
    {
        lv = m_targets.getSource();
    }
 
    DynamicObject* dynObj = p_caster->getWorldMap()->createDynamicObject();
    dynObj->create(u_caster, this, lv, static_cast<uint32_t>(getDuration()), getEffectRadius(effectIndex), DYNAMIC_OBJECT_FARSIGHT_FOCUS);
    dynObj->SetInstanceID(p_caster->GetInstanceID());
    p_caster->setFarsightGuid(dynObj->getGuid());
 
    p_caster->getWorldMap()->changeFarsightLocation(p_caster, dynObj);
}

Here is the call graph for this function:

◆ spellEffectAddHonor()

void Spell::spellEffectAddHonor ( uint8_t effectIndex )

◆ SpellEffectAddHonor()

void Spell::SpellEffectAddHonor ( uint8_t effectIndex )

Definition at line 3895 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget) return;
 
    uint32_t val = getSpellInfo()->getEffectBasePoints(effectIndex);
 
    // TODO: is this correct? -Appled
    if (getSpellInfo()->getAttributesExB() & ATTRIBUTESEXB_IGNORE_LINE_OF_SIGHT) val /= 10;
 
    val += 1;
 
    HonorHandler::AddHonorPointsToPlayer(m_playerTarget, val);
 
    m_playerTarget->sendPvpCredit(val, 0, 5);
}

Here is the call graph for this function:

◆ spellEffectApplyAura()

void Spell::spellEffectApplyAura ( uint8_t effectIndex )

◆ SpellEffectApplyAura()

void Spell::SpellEffectApplyAura ( uint8_t effectIndex )

Definition at line 1822 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr)
        return;
 
#ifdef GM_Z_DEBUG_DIRECTLY
    else
    {
        if (m_unitTarget->isPlayer() && m_unitTarget->IsInWorld() && TO< Player* >(m_unitTarget)->getSession() && TO< Player* >(m_unitTarget)->getSession()->CanUseCommand('z'))
        {
            sChatHandler.BlueSystemMessage(TO< Player* >(m_unitTarget)->getSession(), "[%sSystem%s] |rSpell::SpellEffectApplyAura: %s EffectApplyAuraName [%u] .", MSG_COLOR_WHITE, MSG_COLOR_LIGHTBLUE, MSG_COLOR_SUBWHITE,
                                           i);
        }
    }
#endif
 
    // avoid map corruption.
    if (m_unitTarget->GetInstanceID() != m_caster->GetInstanceID())
        return;
 
    //check if we already have stronger aura
    Aura* pAura;
 
    auto itr = m_pendingAuras.find(m_unitTarget->getGuid());
    //if we do not make a check to see if the aura owner is the same as the caster then we will stack the 2 auras and they will not be visible client sided
    if (itr == m_pendingAuras.end())
    {
        uint32_t Duration = getDuration();
 
        if (ProcedOnSpell)  //Warrior's Blood Frenzy
        {
            switch (getSpellInfo()->getId())
            {
                //SPELL_HASH_BLOOD_FRENZY
                case 16952:
                case 16954:
                case 29836:
                case 29859:
                case 30069:
                case 30070:
                {
                    const auto motherSpellDuration = sSpellDurationStore.lookupEntry(ProcedOnSpell->getDurationIndex());
                    if (motherSpellDuration != nullptr)
                    {
                        if (motherSpellDuration->Duration3 > 0)
                            Duration = motherSpellDuration->Duration3;
                        else if (motherSpellDuration->Duration2 > 0)
                            Duration = motherSpellDuration->Duration2;
                        else
                            Duration = motherSpellDuration->Duration1;
                    }
                } break;
            }
        }
 
        // Handle diminishing returns, if it should be resisted, it'll make duration 0 here.
        if (!(getSpellInfo()->isPassive())) // Passive
        {
            m_unitTarget->applyDiminishingReturnTimer(&Duration, getSpellInfo());
        }
 
        if (!Duration)
        {
            sendCastResult(SPELL_FAILED_IMMUNE);
            return;
        }
 
        std::unique_ptr<Aura> auraHolder;
        if (g_caster && g_caster->getCreatedByGuid() && g_caster->getUnitOwner())
            auraHolder = sSpellMgr.newAura(getSpellInfo(), Duration, g_caster->getUnitOwner(), m_unitTarget, m_triggeredSpell, i_caster);
        else
            auraHolder = sSpellMgr.newAura(getSpellInfo(), Duration, m_caster, m_unitTarget, m_triggeredSpell, i_caster);
 
        auraHolder->pSpellId = pSpellId; //this is required for triggered spells
        auraHolder->m_castedItemId = castedItemId;
 
        const auto [itr, _] = m_pendingAuras.try_emplace(m_unitTarget->getGuid(), 0, std::move(auraHolder));
        pAura = itr->second.aur.get();
    }
    else
    {
        pAura = itr->second.aur.get();
    }
    switch (m_spellInfo->getId())
    {
        case 27907:
        {
            if (m_unitTarget->getEntry() == 15941)
            {
                m_unitTarget->sendChatMessage(CHAT_MSG_MONSTER_SAY, LANG_UNIVERSAL, "What? Oh, not this again!");
            }
            else if (m_unitTarget->getEntry() == 15945)
            {
                m_unitTarget->sendChatMessage(CHAT_MSG_MONSTER_SAY, LANG_UNIVERSAL, "You can't do this to me! We had a deal!");
            }
            else
            {
                sendCastResult(SPELL_FAILED_BAD_TARGETS);
                return;
            }
        }break;
        case 28880:
        {
            if (!p_caster)
                break;
 
            if (m_unitTarget->getEntry() == 16483)
            {
                m_unitTarget->removeAllAurasById(29152);
                m_unitTarget->setStandState(STANDSTATE_STAND);
                static const char* testo[12] = { "None", "Warrior", "Paladin", "Hunter", "Rogue", "Priest", "Death Knight", "Shaman", "Mage", "Warlock", "None", "Druid" };
                char msg[150];
                snprintf(msg, 150, "Many thanks to you %s. I'd best get to the crash site and see how I can help out. Until we meet again...", testo[p_caster->getClass()]);
                m_unitTarget->sendChatMessage(CHAT_MSG_MONSTER_SAY, LANG_UNIVERSAL, msg);
                ((Creature*)m_unitTarget)->Despawn(900000, 300000);
            }
        }break;
        case 38177:
        {
            if (!p_caster)
                break;
 
            if (m_unitTarget->getEntry() == 21387)
            {
                ((Creature*)m_unitTarget)->Despawn(5000, 360000);
                p_caster->castSpell(p_caster, 38178, true);
            }
            else
            {
                sendCastResult(SPELL_FAILED_BAD_TARGETS);
                return;
            }
        }break;
    }
 
    if (!pAura)
    {
        sLogger.failure("Warning tried to add Aura Effect for nonexistant Aura returning!");
        return;
    }
 
    pAura->addAuraEffect(static_cast<AuraEffect>(getSpellInfo()->getEffectApplyAuraName(effectIndex)), damage, getSpellInfo()->getEffectMiscValue(effectIndex), effectPctModifier[effectIndex], isEffectDamageStatic[effectIndex], effectIndex);
}

Here is the call graph for this function:

◆ spellEffectApplyEnemyAA()

void Spell::spellEffectApplyEnemyAA ( uint8_t effectIndex )

◆ SpellEffectApplyEnemyAA()

void Spell::SpellEffectApplyEnemyAA ( uint8_t effectIndex )

Definition at line 5948 of file SpellEffects.Legacy.cpp.

{
    ApplyAreaAura(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectApplyFriendAA()

void Spell::spellEffectApplyFriendAA ( uint8_t effectIndex )

◆ SpellEffectApplyFriendAA()

void Spell::SpellEffectApplyFriendAA ( uint8_t effectIndex )

Definition at line 5943 of file SpellEffects.Legacy.cpp.

{
    ApplyAreaAura(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectApplyGroupAA()

void Spell::spellEffectApplyGroupAA ( uint8_t effectIndex )

◆ SpellEffectApplyGroupAA()

void Spell::SpellEffectApplyGroupAA ( uint8_t effectIndex )

Definition at line 3655 of file SpellEffects.Legacy.cpp.

{
    ApplyAreaAura(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectApplyOwnerAA()

void Spell::spellEffectApplyOwnerAA ( uint8_t effectIndex )

◆ SpellEffectApplyOwnerAA()

void Spell::SpellEffectApplyOwnerAA ( uint8_t effectIndex )

Definition at line 6036 of file SpellEffects.Legacy.cpp.

{
    ApplyAreaAura(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectApplyPetAA()

void Spell::spellEffectApplyPetAA ( uint8_t effectIndex )

◆ SpellEffectApplyPetAA()

void Spell::SpellEffectApplyPetAA ( uint8_t effectIndex )

Definition at line 5515 of file SpellEffects.Legacy.cpp.

{
    ApplyAreaAura(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectApplyRaidAA()

void Spell::spellEffectApplyRaidAA ( uint8_t effectIndex )

◆ SpellEffectApplyRaidAA()

void Spell::SpellEffectApplyRaidAA ( uint8_t effectIndex )

Definition at line 4415 of file SpellEffects.Legacy.cpp.

{
    ApplyAreaAura(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectAttackMe()

void Spell::spellEffectAttackMe ( uint8_t effectIndex )

◆ SpellEffectAttackMe()

void Spell::SpellEffectAttackMe ( uint8_t effectIndex )

Definition at line 5415 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    if (!m_unitTarget->getThreatManager().canHaveThreatList())
        return;
 
    ThreatManager& mgr = m_unitTarget->getThreatManager();
    if (mgr.getCurrentVictim() == u_caster)
        return;
 
    if (!mgr.isThreatListEmpty())
    {
        mgr.addThreat(u_caster, 20.0f, nullptr, false, false);
        // Set threat equal to highest threat currently on target
        mgr.matchUnitThreatToHighestThreat(u_caster);
 
        // Call on AIInterface
        if (m_unitTarget->getAIInterface())
            m_unitTarget->getAIInterface()->eventOnTaunt(u_caster);
    }
}

Here is the call graph for this function:

◆ spellEffectBind()

void Spell::spellEffectBind ( uint8_t effectIndex )

◆ SpellEffectBind()

void Spell::SpellEffectBind ( uint8_t effectIndex )

Definition at line 2373 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget || !m_playerTarget->isAlive() || !m_caster)
        return;
 
    WorldPacket data(45);
    uint32_t areaid = m_playerTarget->getZoneId();
    uint32_t mapid = m_playerTarget->GetMapId();
    if (getSpellInfo()->getEffectMiscValue(effectIndex))
    {
        areaid = getSpellInfo()->getEffectMiscValue(effectIndex);
        auto at = MapManagement::AreaManagement::AreaStorage::GetAreaById(areaid);
        if (!at)
            return;
        mapid = at->map_id;
    }
 
    m_playerTarget->setBindPoint(m_playerTarget->GetPositionX(), m_playerTarget->GetPositionY(), m_playerTarget->GetPositionZ(), m_playerTarget->GetOrientation(), mapid, areaid);
 
    m_playerTarget->getSession()->SendPacket(SmsgBindPointUpdate(m_playerTarget->getBindPosition(), m_playerTarget->getBindMapId(), m_playerTarget->getBindZoneId()).serialise().get());
 
    m_playerTarget->getSession()->SendPacket(SmsgPlayerBound(m_caster->getGuid(), m_playerTarget->getBindZoneId()).serialise().get());
}

Here is the call graph for this function:

◆ spellEffectBlock()

void Spell::spellEffectBlock ( uint8_t effectIndex )

◆ SpellEffectBlock()

void Spell::SpellEffectBlock ( uint8_t effectIndex )

Definition at line 2497 of file SpellEffects.Legacy.cpp.

{
    //i think this actually enables the skill to be able to block melee+ranged attacks
    //value is static and sets value directly which will be modified by other factors
    //  if (m_unitTarget->isPlayer())
    //      m_unitTarget->SetFloatValue(PLAYER_BLOCK_PERCENTAGE,damage);
}

◆ spellEffectBuildingDamage()

void Spell::spellEffectBuildingDamage ( uint8_t effectIndex )

◆ SpellEffectBuildingDamage()

void Spell::SpellEffectBuildingDamage ( uint8_t effectIndex )

Definition at line 4821 of file SpellEffects.Legacy.cpp.

{
    if (m_gameObjTarget == nullptr)
    {
        sLogger.failure("Spell {} ({}) effect %hhu not handled because no target was found. ", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
        return;
    }
 
    if (m_gameObjTarget->GetGameObjectProperties()->type != GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING)
        return;
 
    if (u_caster == nullptr)
        return;
 
    uint32_t spellDamage = m_spellInfo->getEffectBasePoints(effectIndex) + 1;
    Unit* controller = nullptr;
#ifdef FT_VEHICLES
    if (u_caster->getVehicle() != nullptr)
        controller = u_caster->getWorldMap()->getUnit(u_caster->getCharmedByGuid());
#endif
 
    if (controller == nullptr)
        controller = u_caster;
 
    // Baaaam
    GameObject_Destructible* dgo = static_cast<GameObject_Destructible*>(m_gameObjTarget);
    dgo->Damage(spellDamage, u_caster->getGuid(), controller->getGuid(), m_spellInfo->getId());
}

Here is the call graph for this function:

◆ spellEffectCharge()

void Spell::spellEffectCharge ( uint8_t effectIndex )

◆ SpellEffectCharge()

void Spell::SpellEffectCharge ( uint8_t effectIndex )

Definition at line 4988 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isAlive())
        return;
 
    float speed = G3D::fuzzyGt(getSpellInfo()->getSpeed(), 0.0f) ? getSpellInfo()->getSpeed() : SPEED_CHARGE;
 
    LocationVector pos = m_unitTarget->getFirstCollisionPosition(m_unitTarget->getCombatReach(), m_unitTarget->getRelativeAngle(m_caster));
    u_caster->getMovementManager()->moveCharge(pos, speed);
}

Here is the call graph for this function:

◆ spellEffectClearQuest()

void Spell::spellEffectClearQuest ( uint8_t effectIndex )

◆ SpellEffectClearQuest()

void Spell::SpellEffectClearQuest ( uint8_t effectIndex )

Definition at line 4400 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
    {
        sLogger.failure("Spell {} ({}) was not casted on Player, but Spell requires Player to be a target.", m_spellInfo->getId(), m_spellInfo->getName());
        return;
    }
 
    uint32_t questid1 = m_spellInfo->getEffectBasePoints(effectIndex);
    uint32_t questid2 = m_spellInfo->getEffectMiscValue(effectIndex);
 
    m_playerTarget->clearQuest(questid1);
    m_playerTarget->clearQuest(questid2);
}

Here is the call graph for this function:

◆ spellEffectCreateHouse()

void Spell::spellEffectCreateHouse ( uint8_t effectIndex )

◆ SpellEffectCreateHouse()

void Spell::SpellEffectCreateHouse ( uint8_t effectIndex )

Definition at line 4719 of file SpellEffects.Legacy.cpp.

4720{

4721}

◆ spellEffectCreateItem()

void Spell::spellEffectCreateItem ( uint8_t effectIndex )

◆ SpellEffectCreateItem()

void Spell::SpellEffectCreateItem ( uint8_t effectIndex )

Definition at line 2505 of file SpellEffects.Legacy.cpp.

{
    uint32_t spellid = m_spellInfo->getId();
 
    if (m_playerTarget == nullptr)
    {
        sLogger.failure("Spell {} ({}) has a create item effect but no player target!", spellid, m_spellInfo->getName());
        return;
    }
 
 
    uint32_t itemid = m_spellInfo->getEffectItemType(effectIndex);
    uint32_t count = 0;
    uint32_t basecount = m_spellInfo->getEffectDieSides(effectIndex);
    uint32_t difference = m_spellInfo->getEffectBasePoints(effectIndex);
 
    if (itemid == 0)
    {
        sLogger.failure("Spell {} ({}) has a create item effect but no itemid to add, Spell needs to be fixed!", spellid, m_spellInfo->getName());
        return;
    }
 
    ItemProperties const* m_itemProto = sMySQLStore.getItemProperties(itemid);
    if (m_itemProto == nullptr)
    {
        sLogger.failure("Spell {} ({}) has a create item effect but the itemid is invalid!", spellid, m_spellInfo->getName());
        return;
    }
 
    if (difference > basecount)
    {
        count = basecount + difference;
 
    }
    else
    {
        uint32_t mincount = basecount - difference;
        uint32_t maxcount = basecount + difference;
        uint32_t variablecount = maxcount - mincount;
        uint32_t randcount = Util::getRandomUInt(variablecount);
 
        count = mincount + randcount;
    }
 
    uint32_t countperlevel = static_cast<uint32_t>(std::round(m_spellInfo->getEffectRealPointsPerLevel(effectIndex)));
 
    if (countperlevel != 0)
    {
        uint32_t leveldiff = m_spellInfo->getMaxLevel() - m_spellInfo->getBaseLevel();
        uint32_t countforlevel = leveldiff * countperlevel;
 
        count += countforlevel;
    }
 
    // Make sure the count is at least 1 (no need to generate warning from this)
    count = std::max(1u, count);
 
    if (p_caster != nullptr)
    {
        auto skill_line_ability = sSpellMgr.getFirstSkillEntryForSpell(spellid);
 
        // potions learned by discovery variables
        uint32_t cast_chance = 5;
        uint32_t learn_spell = 0;
 
        // tailoring specializations get +1 cloth bonus
        switch (spellid)
        {
            case 36686: //Shadowcloth
                if (p_caster->hasSpell(26801)) count++;
                break;
 
            case 26751: // Primal Mooncloth
                if (p_caster->hasSpell(26798)) count++;
                break;
 
            case 31373: //Spellcloth
                if (p_caster->hasSpell(26797)) count++;
                break;
        }
 
        if ((skill_line_ability != nullptr) && (skill_line_ability->skilline == SKILL_ALCHEMY))
        {
            //Potion Master
            if (m_itemProto->Name.compare("Potion"))
            {
                if (p_caster->hasSpell(28675))
                    while (Util::checkChance(20) && (count < 5))
                        count++;
 
                // Super Rejuvenation Potion
                cast_chance = 2;
                learn_spell = 28586;
            }
 
            //Elixir Master
            if (m_itemProto->Name.compare("Elixir") || m_itemProto->Name.compare("Flask"))
            {
                if (p_caster->hasSpell(28677))
                    while (Util::checkChance(20) && (count < 5))
                        count++;
 
                uint32_t spList[] = { 28590, 28587, 28588, 28591, 28589 };
                cast_chance = 2;
                learn_spell = spList[Util::getRandomUInt(4)];
            }
 
            //Transmutation Master
            if (m_spellInfo->getCategory() == 310)
            {
 
                //rate for primal might is lower than for anything else
                if (m_spellInfo->getId() == 29688)
                {
                    if (p_caster->hasSpell(28672))
                        while (Util::checkChance(40) && (count < 5))
                            count++;
                }
                else
                {
                    if (p_caster->hasSpell(28672))
                        while (Util::checkChance(20) && (count < 5))
                            count++;
                }
 
                uint32_t spList[] = { 28581, 28585, 28585, 28584, 28582, 28580 };
                cast_chance = 5;
                learn_spell = spList[Util::getRandomUInt(5)];
            }
        }
 
        if (!m_playerTarget->getItemInterface()->AddItemById(itemid, count, 0))
        {
            sendCastResult(SPELL_FAILED_TOO_MANY_OF_ITEM);
            return;
        }
 
        if (p_caster != nullptr)
        {
            //random discovery by crafter item id
            switch (itemid)
            {
                case 22845: //Major Arcane Protection Potion
                    cast_chance = 20;
                    learn_spell = 41458;
                    break;
 
                case 22841: //Major Fire Protection Potion
                    cast_chance = 20;
                    learn_spell = 41500;
                    break;
 
                case 22842: //Major Frost Protection Potion
                    cast_chance = 20;
                    learn_spell = 41501;
                    break;
 
                case 22847: //Major Holy Protection Potion
                    // there is none
                    break;
 
                case 22844: //Major Nature Protection Potion
                    cast_chance = 20;
                    learn_spell = 41502;
                    break;
 
                case 22846: //Major Shadow Protection Potion
                    cast_chance = 20;
                    learn_spell = 41503;
                    break;
            }
 
            if ((learn_spell != 0) && (p_caster->getLevel() > 60) && !p_caster->hasSpell(learn_spell) && Util::checkChance(cast_chance))
            {
                SpellInfo const* dspellproto = sSpellMgr.getSpellInfo(learn_spell);
 
                if (dspellproto != nullptr)
                {
                    p_caster->broadcastMessage("%sDISCOVERY! You discovered the %s !|r", MSG_COLOR_YELLOW, dspellproto->getName().c_str());
                    p_caster->addSpell(learn_spell);
                }
                else
                {
                    sLogger.failure("Spell {} ({}) Effect Index %hhu tried to teach a non-existing Spell {} in {}:{}", spellid, m_spellInfo->getName(), effectIndex, learn_spell, __FILE__, __LINE__);
                }
            }
        }
 
        if (skill_line_ability != nullptr)
        {
            const auto skillLine = static_cast<uint16_t>(skill_line_ability->skilline);
            DetermineSkillUp(skillLine);
 
            uint32_t discovered_recipe = 0;
 
            for (auto itr = sMySQLStore._professionDiscoveryStore.begin(); itr != sMySQLStore._professionDiscoveryStore.end(); ++itr)
            {
                const auto& pf = *itr;
                if (spellid == pf->SpellId && p_caster->getSkillLineCurrent(skillLine) >= pf->SkillValue && !p_caster->hasSpell(pf->SpellToDiscover) && Util::checkChance(pf->Chance))
                {
                    discovered_recipe = pf->SpellToDiscover;
                    break;
                }
            }
 
            // if something was discovered teach player that recipe and broadcast message
            if (discovered_recipe != 0)
            {
                SpellInfo const* se = sSpellMgr.getSpellInfo(discovered_recipe);
 
                if (se != nullptr)
                {
                    p_caster->addSpell(discovered_recipe);
 
                    char msg[256];
                    sprintf(msg, "%sDISCOVERY! %s has discovered how to create %s.|r", MSG_COLOR_GOLD, p_caster->getName().c_str(), se->getName().c_str());
 
                    p_caster->getWorldMap()->sendChatMessageToCellPlayers(p_caster, SmsgMessageChat(CHAT_MSG_SYSTEM, LANG_UNIVERSAL, 0, msg, p_caster->getGuid()).serialise().get(), 2, 1, LANG_UNIVERSAL, p_caster->getSession());
                }
                else
                {
                    sLogger.failure("Spell {} ({}) Effect index %hhu tried to teach a non-existing Spell {} in {}:{}", spellid, m_spellInfo->getName(), effectIndex, learn_spell, __FILE__, __LINE__);
                }
            }
        }
    }
    else
    {
        if (!m_playerTarget->getItemInterface()->AddItemById(itemid, count, 0))
            sendCastResult(SPELL_FAILED_TOO_MANY_OF_ITEM);
    }
}

Here is the call graph for this function:

◆ spellEffectCreateItem2()

void Spell::spellEffectCreateItem2 ( uint8_t effectIndex )

◆ SpellEffectCreateItem2()

void Spell::SpellEffectCreateItem2 ( uint8_t effectIndex )

Todo:: This spell effect has also a misc value - meaning is unknown yet

Todo:: Finish this

Definition at line 6110 of file SpellEffects.Legacy.cpp.

{
    ///\todo This spell effect has also a misc value - meaning is unknown yet
    if (p_caster == nullptr)
        return;
 
    uint32_t new_item_id = getSpellInfo()->getEffectItemType(effectIndex);
 
    if (new_item_id != 0)
    {
        // create item
        CreateItem(new_item_id);
    }
    else if (i_caster)
    {
        // provide player with item loot (clams)
        ///\todo Finish this
    }
}

Here is the call graph for this function:

◆ spellEffectCreatePet()

void Spell::spellEffectCreatePet ( uint8_t effectIndex )

◆ SpellEffectCreatePet()

void Spell::SpellEffectCreatePet ( uint8_t effectIndex )

Definition at line 6041 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget)
        return;
 
    if (m_playerTarget->getPet())
        m_playerTarget->getPet()->unSummon();
 
    CreatureProperties const* ci = sMySQLStore.getCreatureProperties(getSpellInfo()->getEffectMiscValue(effectIndex));
    if (ci)
    {
        const auto pet = sObjectMgr.createPet(getSpellInfo()->getEffectMiscValue(effectIndex), nullptr);
        if (!pet->createAsSummon(ci, nullptr, m_playerTarget, m_playerTarget->GetPosition(), 0, m_spellInfo, effectIndex, PET_TYPE_HUNTER))
        {
            pet->DeleteMe();//CreateAsSummon() returns false if an error occurred.
        }
    }
}

Here is the call graph for this function:

◆ spellEffectDefense()

void Spell::spellEffectDefense ( uint8_t effectIndex )

Definition at line 576 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
        return;
 
    if (!m_playerTarget->hasSkillLine(SKILL_DEFENSE))
        m_playerTarget->addSkillLine(SKILL_DEFENSE, 1, 0);
}

Here is the call graph for this function:

◆ spellEffectDestroyAllTotems()

void Spell::spellEffectDestroyAllTotems ( uint8_t effectIndex )

◆ SpellEffectDestroyAllTotems()

void Spell::SpellEffectDestroyAllTotems ( uint8_t effectIndex )

Definition at line 5326 of file SpellEffects.Legacy.cpp.

{
 
    if (p_caster == nullptr || !p_caster->IsInWorld())
        return;
 
    uint32_t RetreivedMana = 0;
    uint32_t refundpercent = m_spellInfo->getEffectBasePoints(effectIndex) + 1;
 
    for (uint8_t i = SUMMON_SLOT_TOTEM_FIRE; i <= SUMMON_SLOT_TOTEM_AIR; ++i)
    {
        const auto* totem = p_caster->getSummonInterface()->getSummonInSlot(static_cast<SummonSlot>(i));
        if (totem == nullptr || !totem->isTotem())
            continue;
 
        const auto spellid = totem->getCreatedBySpellId();
        SpellInfo const* sp = sSpellMgr.getSpellInfo(spellid);
 
        if (sp != nullptr)
        {
            uint32_t cost = 0;
 
            if (sp->getManaCostPercentage() != 0)
                cost = (p_caster->getBaseMana() * sp->getManaCostPercentage()) / 100;
            else
                cost = sp->getManaCost();
 
            RetreivedMana += static_cast<uint32_t>((cost * refundpercent) / 100.0f);
        }
    }
 
    p_caster->getSummonInterface()->killAllTotems();
    p_caster->energize(p_caster, getSpellInfo()->getId(), RetreivedMana, POWER_TYPE_MANA);
}

Here is the call graph for this function:

◆ spellEffectDisenchant()

void Spell::spellEffectDisenchant ( uint8_t effectIndex )

◆ SpellEffectDisenchant()

void Spell::SpellEffectDisenchant ( uint8_t effectIndex )

Definition at line 5077 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster)
        return;
 
    Item* it = p_caster->getItemInterface()->GetItemByGUID(m_targets.getItemTargetGuid());
    if (!it)
    {
        sendCastResult(SPELL_FAILED_CANT_BE_DISENCHANTED);
        return;
    }
 
    //Fill disenchanting loot
    p_caster->setLootGuid(it->getGuid());
    if (!it->m_loot)
    {
        it->m_loot = std::make_unique<Loot>();
        sLootMgr.fillItemLoot(p_caster, it->m_loot.get(), it->getEntry(), 0);
    }
 
    sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Successfully disenchanted item {}", uint32_t(it->getEntry()));
    p_caster->sendLoot(it->getGuid(), LOOT_DISENCHANTING, p_caster->GetMapId());
 
    //We can increase Enchanting skill up to 60
    auto skill = p_caster->getSkillLineCurrent(SKILL_ENCHANTING);
    if (skill && skill < 60)
    {
        if (Util::checkChance(100.0f - skill * 0.75f))
        {
            auto SkillUp = static_cast<uint16_t>(Util::float2int32(1.0f * worldConfig.getFloatRate(RATE_SKILLRATE)));
            if (skill + SkillUp > 60)
                SkillUp = 60 - skill;
 
            p_caster->advanceSkillLine(SKILL_ENCHANTING, SkillUp);
        }
    }
    if (it == i_caster)
        i_caster = nullptr;
}

Here is the call graph for this function:

◆ spellEffectDismissPet()

void Spell::spellEffectDismissPet ( uint8_t effectIndex )

◆ SpellEffectDismissPet()

void Spell::SpellEffectDismissPet ( uint8_t effectIndex )

Definition at line 5168 of file SpellEffects.Legacy.cpp.

{
    // remove pet.. but don't delete so it can be called later
    if (!p_caster) return;
 
    Pet* pPet = p_caster->getPet();
    if (!pPet) return;
    pPet->unSummon();
}

Here is the call graph for this function:

◆ spellEffectDispel()

void Spell::spellEffectDispel ( uint8_t effectIndex )

◆ SpellEffectDispel()

void Spell::SpellEffectDispel ( uint8_t effectIndex )

Definition at line 3792 of file SpellEffects.Legacy.cpp.

{
    if (u_caster == nullptr || m_unitTarget == nullptr)
        return;
 
    uint16_t start, end;
 
    if (u_caster->isValidTarget(m_unitTarget) || getSpellInfo()->getEffectMiscValue(effectIndex) == DISPEL_STEALTH)    // IsAttackable returns false for stealthed
    {
        start = AuraSlots::POSITIVE_SLOT_START;
        end = AuraSlots::POSITIVE_SLOT_END;
        if (m_unitTarget->m_schoolImmunityList[getSpellInfo()->getFirstSchoolFromSchoolMask()])
            return;
    }
    else
    {
        start = AuraSlots::NEGATIVE_SLOT_START;
        end = AuraSlots::NEGATIVE_SLOT_END;
    }
 
    SpellInfo const* aursp;
    std::list< uint32_t > dispelledSpells;
    bool finish = false;
 
    for (uint16_t x = start; x < end; x++)
    {
        if (auto* const aur = m_unitTarget->getAuraWithAuraSlot(x))
        {
            bool AuraRemoved = false;
            aursp = aur->getSpellInfo();
 
            //Nothing can dispel resurrection sickness;
            if (!aur->IsPassive() && !(aursp->getAttributes() & ATTRIBUTES_IGNORE_INVULNERABILITY))
            {
                if (getSpellInfo()->getDispelType() == DISPEL_ALL)
                {
                    dispelledSpells.push_back(aursp->getId());
 
                    aur->removeAura(AURA_REMOVE_ON_DISPEL);
                    AuraRemoved = true;
 
                    if (--damage <= 0)
                        finish = true;
                }
                else if (static_cast<int32_t>(aursp->getDispelType()) == getSpellInfo()->getEffectMiscValue(effectIndex))
                {
                    dispelledSpells.push_back(aursp->getId());
 
                    aur->removeAura(AURA_REMOVE_ON_DISPEL);
                    AuraRemoved = true;
 
                    if (--damage <= 0)
                        finish = true;
                }
 
                if (AuraRemoved)
                {
                    switch (aursp->getId())
                    {
                        //SPELL_HASH_UNSTABLE_AFFLICTION
                        case 30108:
                        case 30404:
                        case 30405:
                        case 31117:
                        case 34438:
                        case 34439:
                        case 35183:
                        case 43522:
                        case 43523:
                        case 47841:
                        case 47843:
                        case 65812:
                        case 65813:
                        case 68154:
                        case 68155:
                        case 68156:
                        case 68157:
                        case 68158:
                        case 68159:
                        {
                            const auto spellInfo = sSpellMgr.getSpellInfo(31117);
                            Spell* spell = sSpellMgr.newSpell(u_caster, spellInfo, true, nullptr);
                            spell->forced_basepoints->set(0, (aursp->calculateEffectValue(0)) * 9);   //damage effect
                            spell->ProcedOnSpell = getSpellInfo();
                            spell->pSpellId = aursp->getId();
                            SpellCastTargets targets(u_caster->getGuid());
                            spell->prepare(&targets);
                        } break;
                    }
                }
            }
            if (finish)
                break;
        }
    }
 
    // send spell dispell log packet
    if (!dispelledSpells.empty())
    {
        m_caster->sendMessageToSet(SmsgSpellDispellLog(m_caster->getGuid(), m_unitTarget->getGuid(), getSpellInfo()->getId(), dispelledSpells).serialise().get(), true);
    }
}

Here is the call graph for this function:

◆ spellEffectDispelMechanic()

void Spell::spellEffectDispelMechanic ( uint8_t effectIndex )

◆ SpellEffectDispelMechanic()

void Spell::SpellEffectDispelMechanic ( uint8_t effectIndex )

Definition at line 5251 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    m_unitTarget->removeAllAurasBySpellMechanic(static_cast<SpellMechanic>(getSpellInfo()->getEffectMiscValue(effectIndex)), false);
}

Here is the call graph for this function:

◆ spellEffectDistract()

void Spell::spellEffectDistract ( uint8_t effectIndex )

◆ SpellEffectDistract()

void Spell::SpellEffectDistract ( uint8_t effectIndex )

Definition at line 4524 of file SpellEffects.Legacy.cpp.

{
    //spellId 1725 Distract:Throws a distraction attracting the all monsters for ten sec's
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    if (m_targets.getDestination().isSet())
    {
        //      m_unitTarget->getAIInterface()->MoveTo(m_targets.m_destX, m_targets.m_destY, m_targets.m_destZ, 0);
        uint32_t Stare_duration = getDuration();
        if (Stare_duration > 30 * 60 * 1000)
            Stare_duration = 10000;//if we try to stare for more then a half an hour then better not stare at all :P (bug)
 
        auto destination = m_targets.getDestination();
        float newo = m_unitTarget->calcRadAngle(m_unitTarget->GetPositionX(), m_unitTarget->GetPositionY(), destination.x, destination.y);
 
        m_unitTarget->pauseMovement(Stare_duration);
        m_unitTarget->setFacing(newo);
    }
 
    //Smoke Emitter 164870
    //Smoke Emitter Big 179066
    //Unit Field Target of
}

Here is the call graph for this function:

◆ spellEffectDodge()

void Spell::spellEffectDodge ( uint8_t effectIndex )

◆ SpellEffectDodge()

void Spell::SpellEffectDodge ( uint8_t effectIndex )

Definition at line 2482 of file SpellEffects.Legacy.cpp.

{
    //i think this actually enables the skill to be able to dodge melee+ranged attacks
    //value is static and sets value directly which will be modified by other factors
    //this is only basic value and will be overwritten elsewhere !!!
    //  if (m_unitTarget->isPlayer())
    //      m_unitTarget->SetFloatValue(PLAYER_DODGE_PERCENTAGE,damage);
}

◆ spellEffectDualWield()

void Spell::spellEffectDualWield ( uint8_t effectIndex )

Definition at line 585 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr)
        return;
 
    m_unitTarget->setDualWield(true);
}

Here is the call graph for this function:

◆ spellEffectDualWield2H()

void Spell::spellEffectDualWield2H ( uint8_t effectIndex )

◆ SpellEffectDualWield2H()

void Spell::SpellEffectDualWield2H ( uint8_t effectIndex )

Definition at line 6072 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget)
        return;
 
    m_playerTarget->setDualWield2H(true);
}

Here is the call graph for this function:

◆ spellEffectDuel()

void Spell::spellEffectDuel ( uint8_t effectIndex )

◆ SpellEffectDuel()

void Spell::SpellEffectDuel ( uint8_t effectIndex )

Definition at line 4723 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster || !p_caster->isAlive())
        return;
 
    if (p_caster->isStealthed())
    {
        sendCastResult(SPELL_FAILED_CANT_DUEL_WHILE_STEALTHED);
        return; // Player is stealth
    }
    if (!m_playerTarget || m_playerTarget == p_caster)
        return;
 
    /* not implemented yet
    \todo dueling zones ? (SPELL_FAILED_NO_DUELING)
    if (player->IsInvisible())
    {
    sendCastResult(SPELL_FAILED_CANT_DUEL_WHILE_INVISIBLE);
    return;
    }
    */
 
    //Player* pTarget = sObjHolder.GetObject<Player>(player->getTargetGuid());      //  hacky.. and will screw up if plr is deselected..
    if (!m_playerTarget)
    {
        sendCastResult(SPELL_FAILED_BAD_TARGETS);
        return; // invalid Target
    }
    if (!m_playerTarget->isAlive())
    {
        sendCastResult(SPELL_FAILED_TARGETS_DEAD);
        return; // Target not alive
    }
    // todo
    /*if (playerTarget->hasUnitStateFlag(UNIT_STATE_ATTACKING))
    {
        sendCastResult(SPELL_FAILED_TARGET_IN_COMBAT);
        return; // Target in combat with another unit
    }*/
    if (m_playerTarget->getDuelPlayer())
    {
        sendCastResult(SPELL_FAILED_TARGET_DUELING);
        return; // Already Dueling
    }
 
    p_caster->requestDuel(m_playerTarget);
}

Here is the call graph for this function:

◆ spellEffectDummy()

void Spell::spellEffectDummy ( uint8_t effectIndex )

Definition at line 499 of file SpellEffects.Legacy.cpp.

{
    // Check that the dummy effect is handled properly in spell script
    // In case it's not, generate warning to debug log
    const auto scriptResult = sScriptMgr.callScriptedSpellOnDummyOrScriptedEffect(this, effectIndex);
    if (scriptResult == SpellScriptCheckDummy::DUMMY_OK)
        return;
 
    if (sObjectMgr.checkForDummySpellScripts(static_cast<Player*>(u_caster), m_spellInfo->getId()))
        return;
 
    if (sScriptMgr.CallScriptedDummySpell(m_spellInfo->getId(), effectIndex, this))
        return;
 
    sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Spell::spellEffectDummy : Spell {} ({}) has a dummy effect index (%hhu), but no handler for it.", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
}

Here is the call graph for this function:

◆ spellEffectDummyMelee()

void Spell::spellEffectDummyMelee ( uint8_t effectIndex )

◆ SpellEffectDummyMelee()

void Spell::SpellEffectDummyMelee ( uint8_t effectIndex )

Definition at line 5520 of file SpellEffects.Legacy.cpp.

{
 
    if (!m_unitTarget || !u_caster)
        return;
 
    switch (getSpellInfo()->getId())
    {
        //SPELL_HASH_OVERPOWER
        case 7384:
        case 7887:
        case 11584:
        case 11585:
        case 14895:
        case 17198:
        case 24407:
        case 32154:
        case 37321:
        case 37529:
        case 43456:
        case 58516:
        case 65924:
        {
            if (p_caster)   //warrior : overpower - let us clear the event and the combopoint count
            {
                p_caster->clearComboPoints(); //some say that we should only remove 1 point per dodge. Due to cooldown you can't cast it twice anyway..
                sEventMgr.RemoveEvents(p_caster, EVENT_COMBO_POINT_CLEAR_FOR_TARGET);
            }
        } break;
 
        case 20243:
        case 30016:
        case 30017:
        case 30022:
        case 36891:
        case 36894:
        case 38849:
        case 38967:
        case 44452:
        case 47497:
        case 47498:
        case 57795:
        case 60018:
        case 62317:
        case 69902:
        {
            //count the number of sunder armors on target
            uint32_t sunder_count = 0;
            SpellInfo const* spellInfo = nullptr;
            for (uint16_t x = AuraSlots::NEGATIVE_SLOT_START; x < AuraSlots::NEGATIVE_SLOT_END; ++x)
            {
                if (const auto* aur = m_unitTarget->getAuraWithAuraSlot(x))
                {
                    switch (aur->getSpellInfo()->getId())
                    {
                        //SPELL_HASH_SUNDER_ARMOR
                        case 7386:
                        case 7405:
                        case 8380:
                        case 11596:
                        case 11597:
                        case 11971:
                        case 13444:
                        case 15502:
                        case 15572:
                        case 16145:
                        case 21081:
                        case 24317:
                        case 25051:
                        case 25225:
                        case 27991:
                        case 30901:
                        case 47467:
                        case 48893:
                        case 50370:
                        case 53618:
                        case 54188:
                        case 57807:
                        case 58461:
                        case 58567:
                        case 59350:
                        case 59608:
                        case 64978:
                        case 65936:
                        case 71554:
                        {
                            sunder_count++;
                            spellInfo = aur->getSpellInfo();
                        } break;
                        default:
                            spellInfo = sSpellMgr.getSpellInfo(7386);
                            break;
                    }
                }
            }
 
            if (spellInfo == nullptr)
                return; //omg how did this happen ?
                        //we should also cast sunder armor effect on target with or without dmg
            Spell* spell = sSpellMgr.newSpell(u_caster, spellInfo, true, nullptr);
            spell->ProcedOnSpell = getSpellInfo();
            spell->pSpellId = getSpellInfo()->getId();
            SpellCastTargets targets(m_unitTarget->getGuid());
            spell->prepare(&targets);
            if (!sunder_count)
                return; //no damage = no joy
            damage = damage * sunder_count;
        } break;
        default:
            break;
    }
 
    switch (getSpellInfo()->getId())
    {
        //SPELL_HASH_HEMORRHAGE
        case 16511:
        case 17347:
        case 17348:
        case 26864:
        case 30478:
        case 37331:
        case 45897:
        case 48660:
        case 65954:
        {
            if (p_caster)
                p_caster->addComboPoints(p_caster->getTargetGuid(), 1);
        } break;
 
        // AMBUSH
        case 8676:
            add_damage = 77;
            return;
            break;          // r1
        case 8724:
            add_damage = 110;
            return;
            break;          // r2
        case 8725:
            add_damage = 138;
            return;
            break;          // r3
        case 11267:
            add_damage = 204;
            return;
            break;      // r4
        case 11268:
            add_damage = 253;
            return;
            break;      // r5
        case 11269:
            add_damage = 319;
            return;
            break;      // r6
        case 27441:
            add_damage = 369;
            return;
            break;      // r7
        case 48689:
            add_damage = 509;
            return;
            break;      // r8
        case 48690:
            add_damage = 770;
            return;
            break;      // r9
        case 48691:
            add_damage = 908;
            return;
            break;      // r10
 
            // BACKSTAB
        case 53:
            add_damage = 15;
            return;
            break;          // r1
        case 2589:
            add_damage = 30;
            return;
            break;          // r2
        case 2590:
            add_damage = 48;
            return;
            break;          // r3
        case 2591:
            add_damage = 69;
            return;
            break;          // r4
        case 8721:
            add_damage = 90;
            return;
            break;          // r5
        case 11279:
            add_damage = 135;
            return;
            break;      // r6
        case 11280:
            add_damage = 165;
            return;
            break;      // r7
        case 11281:
            add_damage = 210;
            return;
            break;      // r8
        case 25300:
            add_damage = 225;
            return;
            break;      // r9
        case 26863:
            add_damage = 255;
            return;
            break;      // r10
        case 48656:
            add_damage = 383;
            return;
            break;      // r11
        case 48657:
            add_damage = 465;
            return;
            break;      // r12
    }
 
    // rogue ambush etc
    for (uint8_t x = 0; x < 3; x++)
        if (getSpellInfo()->getEffect(x) == SPELL_EFFECT_WEAPON_PERCENT_DAMAGE)
        {
            add_damage = damage * (getSpellInfo()->getEffectBasePoints(x) + 1) / 100;
            return;
        }
 
    //rogue - mutilate ads dmg if target is poisoned
    uint32_t pct_dmg_mod = 100;
    if (m_unitTarget->isPoisoned())
    {
        switch (getSpellInfo()->getId())
        {
            //SPELL_HASH_MUTILATE
            case 1329:
            case 5374:
            case 27576:
            case 32319:
            case 32320:
            case 32321:
            case 34411:
            case 34412:
            case 34413:
            case 34414:
            case 34415:
            case 34416:
            case 34417:
            case 34418:
            case 34419:
            case 41103:
            case 48661:
            case 48662:
            case 48663:
            case 48664:
            case 48665:
            case 48666:
            case 60850:
                pct_dmg_mod = 120;
                break;
        }
    }
 
    WeaponDamageType _type;
    if (GetType() == SPELL_DMG_TYPE_RANGED)
        _type = RANGED;
    else
    {
        if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_REQUIRES_OFFHAND_WEAPON)
            _type = OFFHAND;
        else
            _type = MELEE;
    }
    m_targetDamageInfo = u_caster->strike(m_unitTarget, _type, getSpellInfo(), damage, pct_dmg_mod, 0, m_triggeredSpell, true, isForcedCrit, this);
    isTargetDamageInfoSet = true;
}

Here is the call graph for this function:

◆ spellEffectDurabilityDamage()

void Spell::spellEffectDurabilityDamage ( uint8_t effectIndex )

◆ SpellEffectDurabilityDamage()

void Spell::SpellEffectDurabilityDamage ( uint8_t effectIndex )

Definition at line 6223 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isPlayer())
        return;
 
    int16_t slot = int16_t(getSpellInfo()->getEffectMiscValue(effectIndex));
 
    Item* pItem;
    Container* pContainer;
    uint32_t j, k;
 
    // FIXME: some spells effects have value -1/-2
    // Possibly its mean -1 all player equipped items and -2 all items
    if (slot < 0)
    {
        for (k = 0; k < MAX_INVENTORY_SLOT; k++)
        {
            pItem = p_caster->getItemInterface()->GetInventoryItem(static_cast<uint16_t>(k));
            if (pItem != nullptr)
            {
                if (pItem->isContainer())
                {
                    pContainer = static_cast< Container* >(pItem);
                    for (j = 0; j < pContainer->getItemProperties()->ContainerSlots; ++j)
                    {
                        pItem = pContainer->getItem(static_cast<uint16_t>(j));
                        if (pItem != nullptr)
                        {
                            uint32_t maxdur = pItem->getMaxDurability();
                            uint32_t olddur = pItem->getDurability();
                            uint32_t newdur = (olddur)-(damage);
 
                            if (static_cast<int32_t>(newdur) < 0)
                                newdur = 0;
 
                            if (newdur > maxdur)
                                newdur = maxdur;
 
                            pItem->setDurability(newdur);
                        }
                    }
                }
                else
                {
                    uint32_t maxdur = pItem->getMaxDurability();
                    uint32_t olddur = pItem->getDurability();
                    uint32_t newdur = (olddur)-(damage);
 
                    if (static_cast<int32_t>(newdur) < 0)
                        newdur = 0;
 
                    if (newdur > maxdur)
                        newdur = maxdur;
 
                    // Apply / Disapply enchantements from this item
                    pItem->setDurability(newdur);
                    if (newdur == 0 && olddur > 0)
                        p_caster->applyItemMods(pItem, static_cast<uint16_t>(k), false);
                    else if (newdur > 0 && olddur == 0)
                        p_caster->applyItemMods(pItem, static_cast<uint16_t>(k), true);
                }
            }
        }
        return;
    }
 
    // invalid slot value
    if (slot >= INVENTORY_SLOT_BAG_END)
        return;
 
    pItem = p_caster->getItemInterface()->GetInventoryItem(slot);
    if (pItem)
    {
        uint32_t maxdur = pItem->getMaxDurability();
        uint32_t olddur = pItem->getDurability();
        uint32_t newdur = (olddur)-(damage);
 
        if (static_cast<int32_t>(newdur) < 0)
            newdur = 0;
 
        if (newdur > maxdur)
            newdur = maxdur;
 
        pItem->setDurability(newdur);
 
        // Apply / Disapply enchantements from this item
        if (newdur == 0 && olddur > 0)
            p_caster->applyItemMods(pItem, slot, false);
        else if (newdur > 0 && olddur == 0)
            p_caster->applyItemMods(pItem, slot, true);
    }
}

Here is the call graph for this function:

◆ spellEffectDurabilityDamagePCT()

void Spell::spellEffectDurabilityDamagePCT ( uint8_t effectIndex )

◆ SpellEffectDurabilityDamagePCT()

void Spell::SpellEffectDurabilityDamagePCT ( uint8_t effectIndex )

Definition at line 6316 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isPlayer())
        return;
 
    int16_t slot = int16_t(getSpellInfo()->getEffectMiscValue(effectIndex));
 
    Item* pItem;
    Container* pContainer;
    uint32_t j, k;
 
    // FIXME: some spells effects have value -1/-2
    // Possibly its mean -1 all player equipped items and -2 all items
    if (slot < 0)
    {
        for (k = 0; k < MAX_INVENTORY_SLOT; ++k)
        {
            pItem = p_caster->getItemInterface()->GetInventoryItem(static_cast<uint16_t>(k));
            if (pItem != nullptr)
            {
                if (pItem->isContainer())
                {
                    pContainer = static_cast< Container* >(pItem);
                    for (j = 0; j < pContainer->getItemProperties()->ContainerSlots; ++j)
                    {
                        pItem = pContainer->getItem(static_cast<uint16_t>(j));
                        if (pItem != nullptr)
                        {
                            uint32_t maxdur = pItem->getMaxDurability();
                            uint32_t olddur = pItem->getDurability();
                            uint32_t newdur = (olddur - (uint32_t)(maxdur * (damage / 100.0)));
 
                            if (static_cast<int32_t>(newdur) < 0)
                                newdur = 0;
 
                            if (newdur > maxdur)
                                newdur = maxdur;
 
                            pItem->setDurability(newdur);
                        }
                    }
                }
                else
                {
                    uint32_t maxdur = pItem->getMaxDurability();
                    uint32_t olddur = pItem->getDurability();
                    uint32_t newdur = (olddur - (uint32_t)(maxdur * (damage / 100.0)));
 
                    if (static_cast<int32_t>(newdur) < 0)
                        newdur = 0;
 
                    if (newdur > maxdur)
                        newdur = maxdur;
 
                    // Apply / Disapply enchantements from this item
                    pItem->setDurability(newdur);
                    if (newdur == 0 && olddur > 0)
                        p_caster->applyItemMods(pItem, static_cast<uint16_t>(k), false);
                    else if (newdur > 0 && olddur == 0)
                        p_caster->applyItemMods(pItem, static_cast<uint16_t>(k), true);
                }
            }
        }
        return;
    }
 
    // invalid slot value
    if (slot >= INVENTORY_SLOT_BAG_END)
        return;
 
    if (damage <= 0)
        return;
 
    pItem = p_caster->getItemInterface()->GetInventoryItem(slot);
    if (pItem)
    {
        uint32_t maxdur = pItem->getMaxDurability();
        uint32_t olddur = pItem->getDurability();
        uint32_t newdur = (olddur - (uint32_t)(maxdur * (damage / 100.0)));
 
        if (static_cast<int32_t>(newdur) < 0)
            newdur = 0;
 
        if (newdur > maxdur)
            newdur = maxdur;
 
        pItem->setDurability(newdur);
 
        // Apply / Disapply enchantements from this item
        if (newdur == 0 && olddur > 0)
            p_caster->applyItemMods(pItem, slot, false);
        else if (newdur > 0 && olddur == 0)
            p_caster->applyItemMods(pItem, slot, true);
    }
}

Here is the call graph for this function:

◆ spellEffectEnchantHeldItem()

void Spell::spellEffectEnchantHeldItem ( uint8_t effectIndex )

◆ SpellEffectEnchantHeldItem()

void Spell::SpellEffectEnchantHeldItem ( uint8_t effectIndex )

Definition at line 4850 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget) return;
 
    Item* item = m_playerTarget->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
    if (!item)
        return;
 
    uint32_t Duration = 0; // Needs to be found in dbc.. I guess?
 
    switch (getSpellInfo()->getId())
    {
        //SPELL_HASH_FLAMETONGUE_WEAPON
        case 8024:
        case 8027:
        case 8030:
        case 16339:
        case 16341:
        case 16342:
        case 25489:
        case 58785:
        case 58789:
        case 58790:
        case 65979:
        //SPELL_HASH_WINDFURY_WEAPON
        case 8232:
        case 8235:
        case 10486:
        case 16362:
        case 25505:
        case 32911:
        case 35886:
        case 58801:
        case 58803:
        case 58804:
            Duration = 10;
            break;
        default:
            Duration = 1800;
            break;
    }
 
    auto spell_item_enchant = sSpellItemEnchantmentStore.lookupEntry(getSpellInfo()->getEffectMiscValue(effectIndex));
 
    if (!spell_item_enchant)
    {
        sLogger.failure("Invalid enchantment entry {} for Spell {}", getSpellInfo()->getEffectMiscValue(effectIndex), getSpellInfo()->getId());
        return;
    }
 
    item->removeEnchantment(TEMP_ENCHANTMENT_SLOT);
    item->addEnchantment(getSpellInfo()->getEffectMiscValue(effectIndex), TEMP_ENCHANTMENT_SLOT, Duration * 1000);
}

Here is the call graph for this function:

◆ spellEffectEnchantItem()

void Spell::spellEffectEnchantItem ( uint8_t effectIndex )

◆ SpellEffectEnchantItem()

void Spell::SpellEffectEnchantItem ( uint8_t effectIndex )

Definition at line 4073 of file SpellEffects.Legacy.cpp.

{
    if (!m_itemTarget || !p_caster)
        return;
 
    // Vellums
    if (getSpellInfo()->getEffectItemType(effectIndex) && (m_itemTarget->getEntry() == 39349 ||
        m_itemTarget->getEntry() == 39350 || m_itemTarget->getEntry() == 43146 ||
        m_itemTarget->getEntry() == 38682 || m_itemTarget->getEntry() == 37602 ||
        m_itemTarget->getEntry() == 43145))
    {
        uint32_t itemid = getSpellInfo()->getEffectItemType(effectIndex);
        ItemProperties const* it = sMySQLStore.getItemProperties(itemid);
        if (it == nullptr)
        {
            p_caster->getSession()->SystemMessage("Item is missing, report this to devs. Entry: %u", itemid);
            return;
        }
 
        auto pItem = sObjectMgr.createItem(itemid, p_caster);
        if (pItem == nullptr)
            return;
 
        p_caster->getItemInterface()->RemoveItemAmt(m_itemTarget->getEntry(), 1);
        p_caster->getItemInterface()->AddItemToFreeSlot(std::move(pItem));
 
        return;
    }
 
    auto spell_item_enchant = sSpellItemEnchantmentStore.lookupEntry(getSpellInfo()->getEffectMiscValue(effectIndex));
 
    if (!spell_item_enchant)
    {
        sLogger.failure("Invalid enchantment entry {} for Spell {}", getSpellInfo()->getEffectMiscValue(effectIndex), getSpellInfo()->getId());
        return;
    }
 
    if (p_caster->getSession()->hasPermissions())
        sGMLog.writefromsession(p_caster->getSession(), "enchanted item for %s", m_itemTarget->getOwner()->getName().c_str());
 
    //remove other perm enchantment that was enchanted by profession
    m_itemTarget->removeEnchantment(PERM_ENCHANTMENT_SLOT);
    const auto addedEnchantment = m_itemTarget->addEnchantment(getSpellInfo()->getEffectMiscValue(effectIndex), PERM_ENCHANTMENT_SLOT, 0);
    if (!addedEnchantment)
        return; // Apply failed
 
    if (!i_caster)
        DetermineSkillUp();
}

Here is the call graph for this function:

◆ spellEffectEnchantItemPrismatic()

void Spell::spellEffectEnchantItemPrismatic ( uint8_t effectIndex )

◆ SpellEffectEnchantItemPrismatic()

void Spell::SpellEffectEnchantItemPrismatic ( uint8_t effectIndex )

Definition at line 6080 of file SpellEffects.Legacy.cpp.

{
#if VERSION_STRING < WotLK
    return;
#else
    if (!m_itemTarget || !p_caster)
        return;
 
    auto spell_item_enchant = sSpellItemEnchantmentStore.lookupEntry(m_spellInfo->getEffectMiscValue(effectIndex));
 
    if (!spell_item_enchant)
    {
        sLogger.failure("Invalid enchantment entry {} for Spell {}", getSpellInfo()->getEffectMiscValue(effectIndex), getSpellInfo()->getId());
        return;
    }
 
    if (p_caster->getSession()->hasPermissions())
        sGMLog.writefromsession(p_caster->getSession(), "enchanted item for %s", m_itemTarget->getOwner()->getName().c_str());
 
    //remove other socket enchant
    m_itemTarget->removeEnchantment(PRISMATIC_ENCHANTMENT_SLOT);
    const auto addedEnchantment = m_itemTarget->addEnchantment(m_spellInfo->getEffectMiscValue(effectIndex), PRISMATIC_ENCHANTMENT_SLOT, 0);
 
    if (!addedEnchantment)
        return; // Apply failed
 
    m_itemTarget->m_isDirty = true;
#endif
}

Here is the call graph for this function:

◆ spellEffectEnchantItemTemporary()

void Spell::spellEffectEnchantItemTemporary ( uint8_t effectIndex )

◆ SpellEffectEnchantItemTemporary()

void Spell::SpellEffectEnchantItemTemporary ( uint8_t effectIndex )

Definition at line 4123 of file SpellEffects.Legacy.cpp.

{
    if ((m_itemTarget == nullptr) || (p_caster == nullptr))
        return;
 
    uint32_t Duration = m_spellInfo->getEffectBasePoints(effectIndex);
    uint32_t EnchantmentID = m_spellInfo->getEffectMiscValue(effectIndex);
 
    // don't allow temporary enchants unless we're the owner of the item
    if (m_itemTarget->getOwner() != p_caster)
        return;
 
    if (Duration == 0)
    {
        sLogger.failure("Spell {} ({}) has no enchantment duration. Spell needs to be fixed!", m_spellInfo->getId(), m_spellInfo->getName());
        return;
    }
 
    if (EnchantmentID == 0)
    {
        sLogger.failure("Spell {} ({}) has no enchantment ID. Spell needs to be fixed!", m_spellInfo->getId(), m_spellInfo->getName());
        return;
    }
 
    auto spell_item_enchant = sSpellItemEnchantmentStore.lookupEntry(EnchantmentID);
    if (spell_item_enchant == nullptr)
    {
        sLogger.failure("Invalid enchantment entry {} for Spell {}", EnchantmentID, getSpellInfo()->getId());
        return;
    }
 
    m_itemTarget->removeEnchantment(TEMP_ENCHANTMENT_SLOT);
 
    const auto addedEnchantment = m_itemTarget->addEnchantment(EnchantmentID, TEMP_ENCHANTMENT_SLOT, Duration * 1000);
    if (!addedEnchantment)
        return; // Apply failed
 
    auto skill_line_ability = sSpellMgr.getFirstSkillEntryForSpell(getSpellInfo()->getId());
    if (skill_line_ability != nullptr)
        DetermineSkillUp(static_cast<uint16_t>(skill_line_ability->skilline), m_itemTarget->getItemProperties()->ItemLevel);
}

Here is the call graph for this function:

◆ spellEffectEnergize()

void Spell::spellEffectEnergize ( uint8_t effectIndex )

◆ SpellEffectEnergize()

void Spell::SpellEffectEnergize ( uint8_t effectIndex )

Definition at line 3199 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    uint32_t modEnergy = 0;
    switch (getSpellInfo()->getId())
    {
        case 30824: // Shamanistic Rage
            modEnergy = damage * getUnitTarget()->getCalculatedAttackPower() / 100;
            break;
        case 31786: // Paladin - Spiritual Attunement
            if (ProcedOnSpell)
            {
                SpellInfo const* motherspell = sSpellMgr.getSpellInfo(pSpellId);
                if (motherspell)
                {
                    //heal amount from procspell (we only proceed on a heal spell)
                    uint32_t healamt = 0;
                    if (ProcedOnSpell->getEffect(0) == SPELL_EFFECT_HEAL || ProcedOnSpell->getEffect(0) == SPELL_EFFECT_SCRIPT_EFFECT)
                        healamt = ProcedOnSpell->calculateEffectValue(0);
                    else if (ProcedOnSpell->getEffect(1) == SPELL_EFFECT_HEAL || ProcedOnSpell->getEffect(1) == SPELL_EFFECT_SCRIPT_EFFECT)
                        healamt = ProcedOnSpell->calculateEffectValue(1);
                    else if (ProcedOnSpell->getEffect(2) == SPELL_EFFECT_HEAL || ProcedOnSpell->getEffect(2) == SPELL_EFFECT_SCRIPT_EFFECT)
                        healamt = ProcedOnSpell->calculateEffectValue(2);
                    modEnergy = (motherspell->calculateEffectValue(0)) * (healamt) / 100;
                }
            }
            break;
        case 57669:
        {
            modEnergy = Util::float2int32(0.01f * m_unitTarget->getBaseMana());
        }
        break;
        case 31930:
        {
            if (u_caster)
                modEnergy = Util::float2int32(0.25f * m_unitTarget->getBaseMana());
        }
        break;
        case 2687: // Improved Bloodrage, dirty fix
        {
            modEnergy = damage;
            if (p_caster)
            {
                if (p_caster->hasSpell(12818))
                    modEnergy += 110; //60
                if (p_caster->hasSpell(12301))
                    modEnergy += 60; //30
            }
        }
        break;
        default:
            modEnergy = damage;
            break;
    }
 
    if (m_unitTarget->hasAurasWithId(17619))
        modEnergy = uint32_t(modEnergy * 1.4f);
 
    if (u_caster)
        u_caster->energize(m_unitTarget, getSpellInfo()->getId(), modEnergy, static_cast<PowerType>(getSpellInfo()->getEffectMiscValue(effectIndex)));
}

Here is the call graph for this function:

◆ spellEffectEnvironmentalDamage()

void Spell::spellEffectEnvironmentalDamage ( uint8_t effectIndex )

◆ SpellEffectEnvironmentalDamage()

void Spell::SpellEffectEnvironmentalDamage ( uint8_t effectIndex )

Definition at line 1966 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget) return;
 
    if (m_playerTarget->m_schoolImmunityList[getSpellInfo()->getFirstSchoolFromSchoolMask()])
    {
        sendCastResult(SPELL_FAILED_IMMUNE);
        return;
    }
    //this is GO, not unit
    m_targetDamageInfo = m_caster->doSpellDamage(m_playerTarget, getSpellInfo()->getId(), static_cast<float_t>(damage), effectIndex, m_triggeredSpell, false, false, isForcedCrit, this);
    isTargetDamageInfoSet = true;
 
    m_playerTarget->sendEnvironmentalDamageLogPacket(m_playerTarget->getGuid(), DAMAGE_FIRE, damage);
}

Here is the call graph for this function:

◆ spellEffectFeedPet()

void Spell::spellEffectFeedPet ( uint8_t effectIndex )

◆ SpellEffectFeedPet()

void Spell::SpellEffectFeedPet ( uint8_t effectIndex )

Cast feed pet effect

effect is item level and pet level dependent, aura ticks are 35, 17, 8 (*1000) happiness

Definition at line 5132 of file SpellEffects.Legacy.cpp.

{
    // food flags and food level are checked in Spell::CanCast()
    if (!m_itemTarget || !p_caster)
        return;
 
    Pet* pPet = p_caster->getPet();
    if (!pPet)
        return;
 
    /** Cast feed pet effect
    - effect is item level and pet level dependent, aura ticks are 35, 17, 8 (*1000) happiness*/
    int8_t deltaLvl = static_cast<int8_t>(pPet->getLevel() - m_itemTarget->getItemProperties()->ItemLevel);
    damage /= 1000; //damage of Feed pet spell is 35000
    if (deltaLvl > 10) damage = damage >> 1;//divide by 2
    if (deltaLvl > 20) damage = damage >> 1;
    damage *= 1000;
 
    const auto spellInfo = sSpellMgr.getSpellInfo(getSpellInfo()->getEffectTriggerSpell(effectIndex));
    Spell* sp = sSpellMgr.newSpell(p_caster, spellInfo, true, nullptr);
    sp->forced_basepoints->set(0, damage);
    SpellCastTargets tgt(pPet->getGuid());
    sp->prepare(&tgt);
 
    if (m_itemTarget->getStackCount() > 1)
    {
        m_itemTarget->modStackCount(-1);
        m_itemTarget->m_isDirty = true;
    }
    else
    {
        p_caster->getItemInterface()->SafeFullRemoveItemByGuid(m_itemTarget->getGuid());
        m_itemTarget = nullptr;
    }
}

Here is the call graph for this function:

◆ spellEffectForceCast()

void Spell::spellEffectForceCast ( uint8_t effectIndex )

Definition at line 680 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || getUnitCaster() == nullptr)
        return;
 
    const auto triggerInfo = sSpellMgr.getSpellInfo(getSpellInfo()->getEffectTriggerSpell(effectIndex));
    if (triggerInfo == nullptr)
        return;
 
    // TODO: figure the logic here, sometimes target should be original caster and sometimes effect target
    // hackfixing for now -Appled
    Unit* target = nullptr;
    switch (getSpellInfo()->getId())
    {
        case 72378: // Deathbringer Saurfang - Blood Nova 10m
        case 73058: // Deathbringer Saurfang - Blood Nova 25m
            target = m_unitTarget;
            break;
        default:
            target = getUnitCaster();
            break;
    }
 
    // TODO: original caster can also be gameobject
    m_unitTarget->castSpell(target, triggerInfo, true);
}

Here is the call graph for this function:

◆ SpellEffectForceDeselect()

void Spell::SpellEffectForceDeselect ( uint8_t effectIndex )

Definition at line 6433 of file SpellEffects.Legacy.cpp.

{
    //clear focus SMSG_BREAK_TARGET
 
    //clear target
    m_caster->sendMessageToSet(SmsgClearTarget(m_caster->getGuid()).serialise().get(), true);
 
    //stop attacking and pet target
}

Here is the call graph for this function:

◆ spellEffectForgetSpecialization()

void Spell::spellEffectForgetSpecialization ( uint8_t effectIndex )

◆ SpellEffectForgetSpecialization()

void Spell::SpellEffectForgetSpecialization ( uint8_t effectIndex )

Definition at line 5980 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget) return;
 
    uint32_t spellid = getSpellInfo()->getEffectTriggerSpell(effectIndex);
    m_playerTarget->removeSpell(spellid, false);
 
    sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Player {} have forgot spell {} from spell {} (caster: {})", m_playerTarget->getGuidLow(), spellid, getSpellInfo()->getId(), m_caster->getGuidLow());
}

Here is the call graph for this function:

◆ spellEffectHeal()

void Spell::spellEffectHeal ( uint8_t effectIndex )

◆ SpellEffectHeal()

void Spell::SpellEffectHeal ( uint8_t effectIndex )

Definition at line 2005 of file SpellEffects.Legacy.cpp.

{
    if (p_caster != nullptr)
    {
        // HACKY but with SM_FEffect2_bonus it doesnt work
        uint32_t fireResistanceAura[] =
        {
            //SPELL_HASH_FIRE_RESISTANCE_AURA
            19891,
            19899,
            19900,
            27153,
            48947,
            0
        };
 
        uint32_t frostResistanceAura[] =
        {
            //SPELL_HASH_FROST_RESISTANCE_AURA
            19888,
            19897,
            19898,
            27152,
            48945,
            0
        };
 
        uint32_t shadowResistanceAura[] =
        {
            //SPELL_HASH_SHADOW_RESISTANCE_AURA
            19876,
            19895,
            19896,
            27151,
            48943,
            0
        };
 
        uint32_t retributionAura[] =
        {
            //SPELL_HASH_RETRIBUTION_AURA
            7294,
            8990,
            10298,
            10299,
            10300,
            10301,
            13008,
            27150,
            54043,
            0
        };
 
        uint32_t devotionAura[] =
        {
            //SPELL_HASH_DEVOTION_AURA
            465,
            643,
            1032,
            8258,
            10290,
            10291,
            10292,
            10293,
            17232,
            27149,
            41452,
            48941,
            48942,
            52442,
            57740,
            58944,
            0
        };
 
        // Apply this only on targets, which have one of paladins auras
        if (m_unitTarget && (m_unitTarget->hasAurasWithId(devotionAura) || m_unitTarget->hasAurasWithId(retributionAura) ||
            m_unitTarget->hasAurasWithId(19746) || m_unitTarget->hasAurasWithId(32223) || m_unitTarget->hasAurasWithId(fireResistanceAura) ||
            m_unitTarget->hasAurasWithId(frostResistanceAura) || m_unitTarget->hasAurasWithId(shadowResistanceAura)))
        {
            if (p_caster->hasSpell(20140))     // Improved Devotion Aura Rank 3
                damage = (int32_t)(damage * 1.06);
            else if (p_caster->hasSpell(20139))     // Improved Devotion Aura Rank 2
                damage = (int32_t)(damage * 1.04);
            else if (p_caster->hasSpell(20138))     // Improved Devotion Aura Rank 1
                damage = (int32_t)(damage * 1.02);
        }
 
        if (p_caster->hasSpell(54943) && p_caster->hasAurasWithId(20165))       // Glyph of Seal of Light
            damage = (int32_t)(damage * 1.05);
    }
 
    auto heal = damage;
 
    if (getSpellInfo()->getEffectChainTarget(effectIndex))    //chain
    {
        if (!chaindamage)
        {
            chaindamage = heal;
            m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(chaindamage), m_triggeredSpell, false, false, isForcedCrit, this);
            isTargetDamageInfoSet = true;
        }
        else
        {
            int32_t reduce = getSpellInfo()->getEffectDieSides(effectIndex) + 1;
            if (u_caster != nullptr)
            {
                u_caster->applySpellModifiers(SPELLMOD_JUMP_REDUCE, &reduce, getSpellInfo(), this);
            }
            chaindamage -= (reduce * chaindamage) / 100;
            m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(chaindamage), m_triggeredSpell, false, false, isForcedCrit, this);
            isTargetDamageInfoSet = true;
        }
    }
    else
    {
        //yep, the usual special case. This one is shaman talent : Nature's guardian
        //health is below 30%, we have a mother spell to get value from
        switch (getSpellInfo()->getId())
        {
            case 31616:
            {
                if (m_unitTarget && m_unitTarget->isPlayer() && pSpellId && m_unitTarget->getHealthPct() < 30)
                {
                    //check for that 10 second cooldown
                    const auto spellInfo = sSpellMgr.getSpellInfo(pSpellId);
                    if (spellInfo)
                    {
                        //heal value is received by the level of current active talent :s
                        //maybe we should use CalculateEffect(uint32_t i) to gain SM benefits
                        int32_t value = 0;
                        int32_t basePoints = spellInfo->getEffectBasePoints(effectIndex) + 1; //+(m_caster->getLevel()*basePointsPerLevel);
                        uint32_t randomPoints = spellInfo->getEffectDieSides(effectIndex);
                        if (randomPoints <= 1)
                            value = basePoints;
                        else
                            value = basePoints + Util::getRandomUInt(randomPoints);
                        //the value is in percent. Until now it's a fixed 10%
                        const auto amt = m_unitTarget->getMaxHealth()*value / 100.0f;
                        m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, getSpellInfo()->getId(), amt, m_triggeredSpell, false, false, isForcedCrit, this);
                        isTargetDamageInfoSet = true;
                    }
                }
            }
            break;
            //Bloodthirst
            case 23880:
            {
                if (m_unitTarget)
                {
                    m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, getSpellInfo()->getId(), m_unitTarget->getMaxHealth() / 100.0f, m_triggeredSpell, false, false, isForcedCrit, this);
                    isTargetDamageInfoSet = true;
                }
            }
            break;
            case 22845: // Druid: Frenzied Regeneration
            {
                if (m_unitTarget == nullptr || !m_unitTarget->isPlayer() || !m_unitTarget->isAlive())
                    break;
 
                Player* mPlayer = static_cast< Player* >(m_unitTarget);
                if (!mPlayer->isInFeralForm() ||
                    (mPlayer->getShapeShiftForm() != FORM_BEAR &&
                    mPlayer->getShapeShiftForm() != FORM_DIREBEAR))
                    break;
                uint32_t val = mPlayer->getPower(POWER_TYPE_RAGE);
                if (val > 100)
                    val = 100;
                uint32_t HpPerPoint = Util::float2int32((mPlayer->getMaxHealth() * 0.003f));   //0.3% of hp per point of rage
                uint32_t healAmt = HpPerPoint * (val / 10); //1 point of rage = 0.3% of max hp
                mPlayer->modPower(POWER_TYPE_RAGE, -1 * val);
 
                if (val)
                    mPlayer->addSimpleHealingBatchEvent(healAmt, mPlayer, sSpellMgr.getSpellInfo(22845));
            }
            break;
            case 18562: //druid - swiftmend
            {
                if (m_unitTarget)
                {
                    float_t new_dmg = 0.0f;
                    //consume rejuvenetaion and regrowth
 
                    uint32_t regrowth[] =
                    {
                        //SPELL_HASH_REGROWTH
                        8936,
                        8938,
                        8939,
                        8940,
                        8941,
                        9750,
                        9856,
                        9857,
                        9858,
                        16561,
                        20665,
                        22373,
                        22695,
                        26980,
                        27637,
                        28744,
                        34361,
                        39000,
                        39125,
                        48442,
                        48443,
                        66067,
                        67968,
                        67969,
                        67970,
                        69882,
                        71141,
                        0
                    };
                    Aura* taura = m_unitTarget->getAuraWithId(regrowth);    //Regrowth
                    if (taura && taura->getSpellInfo())
                    {
                        uint32_t amplitude = taura->getSpellInfo()->getEffectAmplitude(1) / 1000;
                        if (!amplitude)
                            amplitude = 3;
 
                        //our hapiness is that we did not store the aura mod amount so we have to recalc it
                        Spell* spell = sSpellMgr.newSpell(m_caster, taura->getSpellInfo(), false, nullptr);
                        uint32_t healamount = spell->calculateEffect(1);
                        delete spell;
                        spell = nullptr;
                        new_dmg = healamount * 18.0f / amplitude;
 
                        taura->removeAura();
 
                        //do not remove flag if we still can cast it again
                        uint32_t rejuvenation[] =
                        {
                            //SPELL_HASH_REJUVENATION
                            774,
                            1058,
                            1430,
                            2090,
                            2091,
                            3627,
                            8070,
                            8910,
                            9839,
                            9840,
                            9841,
                            12160,
                            15981,
                            20664,
                            20701,
                            25299,
                            26981,
                            26982,
                            27532,
                            28716,
                            28722,
                            28723,
                            28724,
                            31782,
                            32131,
                            38657,
                            42544,
                            48440,
                            48441,
                            53607,
                            64801,
                            66065,
                            67971,
                            67972,
                            67973,
                            69898,
                            70691,
                            71142,
                            0
                        };
 
                        if (!m_unitTarget->hasAurasWithId(rejuvenation))
                        {
                            m_unitTarget->removeAuraStateAndAuras(AURASTATE_FLAG_SWIFTMEND);
                            sEventMgr.RemoveEvents(m_unitTarget, EVENT_REJUVENATION_FLAG_EXPIRE);
                        }
                    }
                    else
                    {
                        uint32_t rejuvenation[] =
                        {
                            //SPELL_HASH_REJUVENATION
                            774,
                            1058,
                            1430,
                            2090,
                            2091,
                            3627,
                            8070,
                            8910,
                            9839,
                            9840,
                            9841,
                            12160,
                            15981,
                            20664,
                            20701,
                            25299,
                            26981,
                            26982,
                            27532,
                            28716,
                            28722,
                            28723,
                            28724,
                            31782,
                            32131,
                            38657,
                            42544,
                            48440,
                            48441,
                            53607,
                            64801,
                            66065,
                            67971,
                            67972,
                            67973,
                            69898,
                            70691,
                            71142,
                            0
                        };
 
                        taura = m_unitTarget->getAuraWithId(rejuvenation);  //Rejuvenation
                        if (taura  && taura->getSpellInfo())
                        {
                            uint32_t amplitude = taura->getSpellInfo()->getEffectAmplitude(0) / 1000;
                            if (!amplitude) amplitude = 3;
 
                            //our happiness is that we did not store the aura mod amount so we have to recalc it
                            Spell* spell = sSpellMgr.newSpell(m_caster, taura->getSpellInfo(), false, nullptr);
                            uint32_t healamount = spell->calculateEffect(0);
                            delete spell;
                            spell = nullptr;
                            new_dmg = healamount * 12.0f / amplitude;
 
                            taura->removeAura();
 
                            m_unitTarget->removeAuraStateAndAuras(AURASTATE_FLAG_SWIFTMEND);
                            sEventMgr.RemoveEvents(m_unitTarget, EVENT_REJUVENATION_FLAG_EXPIRE);
                        }
                    }
 
                    if (new_dmg > 0.0f)
                    {
                        const auto spellInfo = sSpellMgr.getSpellInfo(18562);
                        Spell* spell = sSpellMgr.newSpell(m_unitTarget, spellInfo, true, nullptr);
                        spell->setUnitTarget(m_unitTarget);
                        m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, spellInfo->getId(), new_dmg, m_triggeredSpell, false, false, isForcedCrit, this);
                        isTargetDamageInfoSet = true;
                        delete spell;
                    }
                }
            }
            break;
            default:
                m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(heal), m_triggeredSpell, false, false, isForcedCrit, this);
                isTargetDamageInfoSet = true;
                break;
        }
    }
}

Here is the call graph for this function:

◆ spellEffectHealMaxHealth()

void Spell::spellEffectHealMaxHealth ( uint8_t effectIndex )

◆ SpellEffectHealMaxHealth()

void Spell::SpellEffectHealMaxHealth ( uint8_t effectIndex )

Definition at line 4428 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    uint32_t dif = m_unitTarget->getMaxHealth() - m_unitTarget->getHealth();
    if (!dif)
    {
        sendCastResult(SPELL_FAILED_ALREADY_AT_FULL_HEALTH);
        return;
    }
 
    m_unitTarget->addSimpleHealingBatchEvent(dif, u_caster, pSpellId != 0 ? sSpellMgr.getSpellInfo(pSpellId) : getSpellInfo());
 
    if (u_caster != nullptr)
    {
        switch (this->getSpellInfo()->getId())
        {
            //SPELL_HASH_LAY_ON_HANDS
            case 633:
            case 2800:
            case 9257:
            case 10310:
            case 17233:
            case 20233:
            case 20236:
            case 27154:
            case 48788:
            case 53778:
                u_caster->castSpell(m_unitTarget, 25771, true);
                break;
            default:
                break;
        }
    }
}

Here is the call graph for this function:

◆ spellEffectHealMechanical()

void Spell::spellEffectHealMechanical ( uint8_t effectIndex )

◆ SpellEffectHealMechanical()

void Spell::SpellEffectHealMechanical ( uint8_t effectIndex )

Definition at line 4643 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isCreature() || static_cast< Creature* >(m_unitTarget)->GetCreatureProperties()->Type != UNIT_TYPE_MECHANICAL)
        return;
 
    m_targetDamageInfo = m_caster->doSpellHealing(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(damage), m_triggeredSpell, false, false, isForcedCrit, this);
    isTargetDamageInfoSet = true;
}

Here is the call graph for this function:

◆ spellEffectHealthLeech()

void Spell::spellEffectHealthLeech ( uint8_t effectIndex )

Definition at line 516 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isAlive())
        return;
 
    m_targetDamageInfo = m_caster->doSpellDamage(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(damage), effIndex, m_triggeredSpell, false, true, isForcedCrit, this);
    isTargetDamageInfoSet = true;
}

Here is the call graph for this function:

◆ spellEffectInebriate()

void Spell::spellEffectInebriate ( uint8_t effectIndex )

◆ SpellEffectInebriate()

void Spell::SpellEffectInebriate ( uint8_t effectIndex )

Definition at line 5117 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
        return;
 
    // Drunkee!
    uint16_t currentDrunk = m_playerTarget->getServersideDrunkValue();
    uint16_t drunkMod = static_cast<uint16_t>(damage)* 256;
    if (currentDrunk + drunkMod > 0xFFFF)
        currentDrunk = 0xFFFF;
    else
        currentDrunk += drunkMod;
    m_playerTarget->setServersideDrunkValue(currentDrunk, i_caster ? i_caster->getEntry() : 0);
}

Here is the call graph for this function:

◆ spellEffectInstantKill()

void Spell::spellEffectInstantKill ( uint8_t effectIndex )

◆ SpellEffectInstantKill()

void Spell::SpellEffectInstantKill ( uint8_t effectIndex )

Definition at line 765 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    //Sacrifice: if spell caster has "void walker" pet, pet dies and spell caster gets a
    /*Sacrifices the Voidwalker, giving its owner a shield that will absorb
    305 damage for 30 sec. While the shield holds, spellcasting will not be \
    interrupted by damage.*/
 
    /*
    Demonic Sacrifice
 
    When activated, sacrifices your summoned demon to grant you an effect that lasts
    30 minutes. The effect is canceled if any Demon is summoned.
    Imp: Increases your Fire damage by 15%.
    Voidwalker: Restores 3% of total Health every 4 sec.
    Succubus: Increases your Shadow damage by 15%.
    Felhunter: Restores 2% of total Mana every 4 sec.
 
    When activated, sacrifices your summoned demon to grant you an effect that lasts $18789d.  The effect is canceled if any Demon is summoned.
 
    Imp: Increases your Fire damage by $18789s1%.
 
    Voidwalker: Restores $18790s1% of total Health every $18790t1 sec.
 
    Succubus: Increases your Shadow damage by $18791s1%.
 
    Felhunter: Restores $18792s1% of total Mana every $18792t1 sec.
 
    */
    uint32_t spellId = getSpellInfo()->getId();
 
    switch (spellId)
    {
        case 48743:
        {
            // retarget? some one test this spell.
            return;
        }
        break;
        case 18788: //Demonic Sacrifice (508745)
        {
            uint32_t DemonicSacEffectSpellId = 0;
            switch (m_unitTarget->getEntry())
            {
                case 416:
                    DemonicSacEffectSpellId = 18789;
                    break; //Imp
                case 417:
                    DemonicSacEffectSpellId = 18792;
                    break; //Felhunter
                case 1860:
                    DemonicSacEffectSpellId = 18790;
                    break; //VoidWalker
                case 1863:
                    DemonicSacEffectSpellId = 18791;
                    break; //Succubus
                case 17252:
                    DemonicSacEffectSpellId = 35701;
                    break; //felguard
            }
            if (DemonicSacEffectSpellId)
            {
                SpellInfo const* se = sSpellMgr.getSpellInfo(DemonicSacEffectSpellId);
                if (se && u_caster)
                    u_caster->castSpell(u_caster, se, true);
            }
        } break;
 
        //SPELL_HASH_SACRIFICE
        case 1050:
        case 7812:
        case 7885:
        case 19438:
        case 19439:
        case 19440:
        case 19441:
        case 19442:
        case 19443:
        case 19444:
        case 19445:
        case 19446:
        case 19447:
        case 20381:
        case 20382:
        case 20383:
        case 20384:
        case 20385:
        case 20386:
        case 22651:
        case 27273:
        case 27492:
        case 30115:
        case 33587:
        case 34661:
        case 47985:
        case 47986:
        case 48001:
        case 48002:
        {
            if (!u_caster || !u_caster->isPet())
                return;
 
            //TO< Pet* >(u_caster)->Dismiss(true);
 
            SpellInfo const* se = sSpellMgr.getSpellInfo(5);
            if (static_cast< Pet* >(u_caster)->getUnitOwner() == nullptr)
                return;
 
            SpellCastTargets targets(u_caster->getGuid());
            Spell* sp = sSpellMgr.newSpell(static_cast< Pet* >(u_caster)->getUnitOwner(), se, true, nullptr);
            sp->prepare(&targets);
            return;
        } break;
 
    }
 
    //SPELL_HASH_DEMONIC_SACRIFICE
    if (getSpellInfo()->getId() == 18788)
    {
        if (!p_caster || !m_unitTarget || !m_unitTarget->isPet())
            return;
 
        //TO< Pet* >(m_unitTarget)->Dismiss(true);
 
        SpellInfo const* se = sSpellMgr.getSpellInfo(5);
 
        SpellCastTargets targets(m_unitTarget->getGuid());
        Spell* sp = sSpellMgr.newSpell(p_caster, se, true, nullptr);
        sp->prepare(&targets);
        return;
    }
    else
    {
        // moar cheaters
        if (!p_caster || (u_caster && u_caster->isPet()))
            return;
 
        if (!p_caster->getSession()->hasPermissions())
            return;
    }
 
    //instant kill effects don't have a log
    //m_caster->SpellNonMeleeDamageLog(m_unitTarget, GetProto()->getId(), m_unitTarget->getHealth(), true);
    // cebernic: the value of instant kill must be higher than normal health,cuz anti health regenerated.
    if (u_caster != nullptr)
        u_caster->dealDamage(m_unitTarget, m_unitTarget->getHealth() << 1, 0);
    else
        m_unitTarget->dealDamage(m_unitTarget, m_unitTarget->getHealth() << 1, 0);
}

Here is the call graph for this function:

◆ spellEffectInterruptCast()

void Spell::spellEffectInterruptCast ( uint8_t effectIndex )

◆ SpellEffectInterruptCast()

void Spell::SpellEffectInterruptCast ( uint8_t effectIndex )

Definition at line 4465 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    if (getSpellInfo()->getAttributesExG() & ATTRIBUTESEXG_INTERRUPT_NPC && m_unitTarget->isPlayer())
        return;
 
    // Get target's current spell (either channeled or generic spell with cast time)
    if (m_unitTarget->isCastingSpell(false, true))
    {
        Spell* TargetSpell = nullptr;
        if (m_unitTarget->getCurrentSpell(CURRENT_CHANNELED_SPELL) != nullptr && m_unitTarget->getCurrentSpell(CURRENT_CHANNELED_SPELL)->getCastTimeLeft() > 0)
        {
            TargetSpell = m_unitTarget->getCurrentSpell(CURRENT_CHANNELED_SPELL);
        }
        // No need to check cast time for generic spells, checked already in Object::isCastingSpell()
        else if (m_unitTarget->getCurrentSpell(CURRENT_GENERIC_SPELL) != nullptr)
        {
            TargetSpell = m_unitTarget->getCurrentSpell(CURRENT_GENERIC_SPELL);
        }
 
        if (TargetSpell != nullptr)
        {
            uint32_t school = TargetSpell->getSpellInfo()->getFirstSchoolFromSchoolMask(); // Get target's casting spell school
            int32_t duration = getDuration(); // Duration of school lockout
 
            // Check for CastingTime (to prevent interrupting instant casts), PreventionType
            // and InterruptFlags of target's casting spell
            if (school
                && (TargetSpell->getState() == SPELL_STATE_CHANNELING
                || (TargetSpell->getState() == SPELL_STATE_CASTING && TargetSpell->getSpellInfo()->getCastingTimeIndex() > 0))
                && TargetSpell->getSpellInfo()->getPreventionType() == PREVENTION_TYPE_SILENCE
                && ((TargetSpell->getSpellInfo()->getInterruptFlags() & CAST_INTERRUPT_ON_AUTOATTACK)
                || (TargetSpell->getSpellInfo()->getChannelInterruptFlags() & CHANNEL_INTERRUPT_ON_MOVEMENT)))
            {
                if (m_unitTarget->isPlayer())
                {
                    // Check for interruption reducing talents
                    int32_t DurationModifier = m_unitTarget->m_mechanicDurationPctMod[MECHANIC_INTERRUPTED];
                    if (DurationModifier >= -100)
                        duration = (duration * (100 + DurationModifier)) / 100;
 
                    // Prevent player from casting in that school
                    static_cast<Player*>(m_unitTarget)->sendPreventSchoolCast(school, duration);
                }
                else
                {
                    // Prevent unit from casting in that school
                    m_unitTarget->m_schoolCastPrevent[school] = duration + Util::getMSTime();
                }
 
                // Interrupt the spell cast
                m_unitTarget->interruptSpell(TargetSpell->getSpellInfo()->getId(), false);
            }
        }
    }
}

Here is the call graph for this function:

◆ spellEffectJumpBehindTarget()

void Spell::spellEffectJumpBehindTarget ( uint8_t effectIndex )

◆ SpellEffectJumpBehindTarget()

void Spell::SpellEffectJumpBehindTarget ( uint8_t effectIndex )

Definition at line 3029 of file Spell.Legacy.cpp.

{
    if (u_caster == nullptr)
        return;
 
    if (!m_targets.hasDestination())
        return;
 
    if (m_targets.getTargetMask() & TARGET_FLAG_UNIT)
    {
        Object* uobj = m_caster->getWorldMap()->getObject(m_targets.getUnitTargetGuid());
 
        if (uobj == nullptr || !uobj->isCreatureOrPlayer())
            return;
        Unit* un = static_cast<Unit*>(uobj);
        float rad = un->getBoundingRadius() + u_caster->getBoundingRadius();
        float angle = float(un->GetOrientation() + M_PI); //behind
        float x = un->GetPositionX() + cosf(angle) * rad;
        float y = un->GetPositionY() + sinf(angle) * rad;
        float z = un->GetPositionZ();
        float o = un->calcRadAngle(x, y, un->GetPositionX(), un->GetPositionY());
       
        float speedXY, speedZ;
        calculateJumpSpeeds(u_caster, getSpellInfo() ,effectIndex, u_caster->getExactDist2d(un->GetPositionX(), un->GetPositionY()), speedXY, speedZ);
        u_caster->getMovementManager()->moveJump(x, y, z, o, speedXY, speedZ, EVENT_JUMP, !m_targets.getUnitTargetGuid());
    }
}

Here is the call graph for this function:

◆ spellEffectJumpTarget()

void Spell::spellEffectJumpTarget ( uint8_t effectIndex )

◆ SpellEffectJumpTarget()

void Spell::SpellEffectJumpTarget ( uint8_t effectIndex )

Definition at line 2926 of file Spell.Legacy.cpp.

{
    if (u_caster == nullptr)
        return;
 
#ifdef FT_VEHICLES
    if (u_caster->getVehicleKit() || u_caster->isTrainingDummy())
        return;
#else
    if (u_caster->isTrainingDummy())
        return;
#endif
 
    float x = 0;
    float y = 0;
    float z = 0;
    float o = 0;
 
    if (m_targets.getTargetMask() & TARGET_FLAG_UNIT)
    {
        Object* uobj = m_caster->getWorldMap()->getObject(m_targets.getUnitTargetGuid());
 
        if (uobj == nullptr || !uobj->isCreatureOrPlayer())
        {
            return;
        }
 
        float rad = m_unitTarget->getBoundingRadius() - u_caster->getBoundingRadius();
 
        float dx = m_caster->GetPositionX() - m_unitTarget->GetPositionX();
        float dy = m_caster->GetPositionY() - m_unitTarget->GetPositionY();
 
        if (dx == 0.0f || dy == 0.0f)
        {
            return;
        }
 
        float alpha = atanf(dy / dx);
        if (dx < 0)
        {
            alpha += M_PI_FLOAT;
        }
 
        x = rad * cosf(alpha) + m_unitTarget->GetPositionX();
        y = rad * sinf(alpha) + m_unitTarget->GetPositionY();
        z = m_unitTarget->GetPositionZ();
    }
    else
    {
        //this can also jump to a point
        if (m_targets.hasSource())
        {
            auto source = m_targets.getSource();
            x = source.x;
            y = source.y;
            z = source.z;
        }
        if (m_targets.hasDestination())
        {
            auto destination = m_targets.getDestination();
            x = destination.x;
            y = destination.y;
            z = destination.z;
        }
    }
 
    float speedZ = 0.0f;
    float speedXY = 0.0f;
 
    o = m_unitTarget->calcRadAngle(u_caster->GetPositionX(), u_caster->GetPositionY(), x, y);
    calculateJumpSpeeds(u_caster, getSpellInfo() ,effectIndex, u_caster->getExactDist2d(x, y), speedXY, speedZ);
    u_caster->getMovementManager()->moveJump(x, y, z, o, speedXY, speedZ);
}

Here is the call graph for this function:

◆ spellEffectKillCredit()

void Spell::spellEffectKillCredit ( uint8_t effectIndex )

◆ SpellEffectKillCredit()

void Spell::SpellEffectKillCredit ( uint8_t effectIndex )

Definition at line 5990 of file SpellEffects.Legacy.cpp.

{
    CreatureProperties const* ci = sMySQLStore.getCreatureProperties(getSpellInfo()->getEffectMiscValue(effectIndex));
    if (m_playerTarget != nullptr && ci != nullptr)
        sQuestMgr._OnPlayerKill(m_playerTarget, getSpellInfo()->getEffectMiscValue(effectIndex), false);
}

Here is the call graph for this function:

◆ spellEffectKnockBack()

void Spell::spellEffectKnockBack ( uint8_t effectIndex )

◆ SpellEffectKnockBack()

void Spell::SpellEffectKnockBack ( uint8_t effectIndex )

Definition at line 4999 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isAlive())
        return;
 
    // Spells with SPELL_EFFECT_KNOCK_BACK (like Thunderstorm) can't knockback target if target has ROOT/STUN
    if (m_unitTarget->hasUnitStateFlag(UNIT_STATE_ROOTED | UNIT_STATE_STUNNED))
        return;
 
    float ratio = 0.1f;
    float speedxy = float(m_spellInfo->getEffectMiscValue(effectIndex)) * ratio;
    float speedz = float(damage) * ratio;
    if (speedxy < 0.01f && speedz < 0.01f)
        return;
 
    float x, y;
#if VERSION_STRING >= TBC
    if (m_spellInfo->getEffect(effectIndex) == SPELL_EFFECT_KNOCK_BACK_DEST)
    {
        if (m_targets.hasDestination())
        {
            auto destination = m_targets.getDestination();
            x = destination.x;
            y = destination.y;
        }
        else
            return;
    }
    else
#endif
    {
        m_caster->getPosition(x, y);
    }
 
    m_unitTarget->knockbackFrom(x, y, speedxy, speedz);
}

Here is the call graph for this function:

◆ spellEffectKnockBack2()

void Spell::spellEffectKnockBack2 ( uint8_t effectIndex )

◆ SpellEffectKnockBack2()

void Spell::SpellEffectKnockBack2 ( uint8_t effectIndex )

Definition at line 5036 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isAlive())
        return;
 
    m_unitTarget->handleKnockback(m_caster, getSpellInfo()->getEffectMiscValue(effectIndex) / 10.0f, damage / 10.0f);
}

Here is the call graph for this function:

◆ spellEffectLeap()

void Spell::spellEffectLeap ( uint8_t effectIndex )

◆ SpellEffectLeap()

void Spell::SpellEffectLeap ( uint8_t effectIndex )

Definition at line 3164 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr)
        return;
 
    float radius = getEffectRadius(effectIndex);
    m_unitTarget->removeAllAurasByAuraInterruptFlag(AURA_INTERRUPT_ON_ANY_DAMAGE_TAKEN);
 
    MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager();
    dtNavMesh* nav = const_cast<dtNavMesh*>(mmap->GetNavMesh(m_caster->GetMapId()));
    // dtNavMeshQuery* nav_query = const_cast<dtNavMeshQuery*>(mmap->GetNavMeshQuery(m_caster->GetMapId(), m_caster->GetInstanceID()));
    //NavMeshData* nav = CollideInterface.GetNavMesh(m_caster->GetMapId());
 
    if (nav != nullptr)
    {
        float destx, desty, destz;
        m_unitTarget->GetPoint(m_unitTarget->GetOrientation(), radius, destx, desty, destz);
        if (m_playerTarget != nullptr)
            m_playerTarget->safeTeleport(m_playerTarget->GetMapId(), m_playerTarget->GetInstanceID(), LocationVector(destx, desty, destz, m_playerTarget->GetOrientation()));
        else
        {
            float speedXY, speedZ;
            calculateJumpSpeeds(u_caster, getSpellInfo(), effectIndex, u_caster->getExactDist2d(m_unitTarget->GetPositionX(), m_unitTarget->GetPositionY()), speedXY, speedZ);
            u_caster->getMovementManager()->moveJump(destx, desty, destz, m_unitTarget->GetOrientation(), speedXY, speedZ, EVENT_JUMP, !m_unitTarget);
        }
    }
    else
    {
        if (m_playerTarget == nullptr)  //let client handle this for players
            return;
 
        m_playerTarget->getSession()->SendPacket(SmsgMoveKnockBack(m_playerTarget->GetNewGUID(), Util::getMSTime(), cosf(m_playerTarget->GetOrientation()), sinf(m_playerTarget->GetOrientation()), radius, -10.0f).serialise().get());
    }
}

Here is the call graph for this function:

◆ spellEffectLearnPetSpell()

void Spell::spellEffectLearnPetSpell ( uint8_t effectIndex )

◆ SpellEffectLearnPetSpell()

void Spell::SpellEffectLearnPetSpell ( uint8_t effectIndex )

Definition at line 4263 of file SpellEffects.Legacy.cpp.

{
    /*if (m_unitTarget && m_caster->getObjectTypeId() == TYPEID_PLAYER)
    {
    if (m_unitTarget->isPet() && m_unitTarget->getObjectTypeId() == TYPEID_UNIT)
    {
    TO< Player* >(m_caster)->AddPetSpell(GetProto()->EffectTriggerSpell[i], m_unitTarget->getEntry());
    }
    }*/
 
    if (m_unitTarget && m_unitTarget->isPet() && p_caster)
    {
        Pet* pPet = static_cast< Pet* >(m_unitTarget);
        if (!pPet->isHunterPet())
            p_caster->addSummonSpell(m_unitTarget->getEntry(), getSpellInfo()->getEffectTriggerSpell(effectIndex));
 
        pPet->addSpell(sSpellMgr.getSpellInfo(getSpellInfo()->getEffectTriggerSpell(effectIndex)));
 
        // Send Packet
        /*      WorldPacket data(SMSG_SET_EXTRA_AURA_INFO_OBSOLETE, 22);
        data << pPet->getGuid() << uint8_t(0) << uint32_t(GetProto()->EffectTriggerSpell[i]) << uint32_t(-1) << uint32_t(0);
        p_caster->getSession()->sendPacket(&data);*/
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectLearnSpec()

void Spell::spellEffectLearnSpec ( uint8_t effectIndex )

◆ SpellEffectLearnSpec()

void Spell::SpellEffectLearnSpec ( uint8_t effectIndex )

Definition at line 6181 of file SpellEffects.Legacy.cpp.

{
    if (p_caster == nullptr)
        return;
 
    p_caster->m_talentSpecsCount = 2;
    p_caster->smsg_TalentsInfo(false);
}

Here is the call graph for this function:

◆ spellEffectLearnSpell()

void Spell::spellEffectLearnSpell ( uint8_t effectIndex )

◆ SpellEffectLearnSpell()

void Spell::SpellEffectLearnSpell ( uint8_t effectIndex )

Definition at line 3660 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr && m_unitTarget && m_unitTarget->isPet()) // something's wrong with this logic here.
    {
        // bug in target map fill?
        //playerTarget = m_caster->getWorldMap()->GetPlayer((uint32_t)m_targets.getUnitTarget());
        SpellEffectLearnPetSpell(effectIndex);
        return;
    }
 
    if (getSpellInfo()->getId() == 483 || getSpellInfo()->getId() == 55884)          // "Learning"
    {
        if (!p_caster) return;
 
        uint32_t spellid = damage;
        if (!spellid || !sSpellMgr.getSpellInfo(spellid)) return;
 
        // learn me!
        p_caster->addSpell(spellid);
 
        // no normal handler
        return;
    }
 
    if (m_playerTarget)
    {
        /*if (u_caster && playerTarget->isHostileTo(u_caster))
        return;*/
 
        uint32_t spellToLearn = getSpellInfo()->getEffectTriggerSpell(effectIndex);
        m_playerTarget->addSpell(spellToLearn);
 
        if (spellToLearn == 2575)   //hacky fix for mining from creatures
            m_playerTarget->addSpell(32606);
 
        if (spellToLearn == 2366)   //hacky fix for herbalism from creatures
            m_playerTarget->addSpell(32605);
 
        //smth is wrong here, first we add this spell to player then we may cast it on player...
        SpellInfo const* spellinfo = sSpellMgr.getSpellInfo(spellToLearn);
        //remove specializations
        switch (spellinfo->getId())
        {
            case 26801: //Shadoweave Tailoring
                m_playerTarget->removeSpell(26798, false); //Mooncloth Tailoring
                m_playerTarget->removeSpell(26797, false); //Spellfire Tailoring
                break;
            case 26798: // Mooncloth Tailoring
                m_playerTarget->removeSpell(26801, false); //Shadoweave Tailoring
                m_playerTarget->removeSpell(26797, false); //Spellfire Tailoring
                break;
            case 26797: //Spellfire Tailoring
                m_playerTarget->removeSpell(26801, false); //Shadoweave Tailoring
                m_playerTarget->removeSpell(26798, false); //Mooncloth Tailoring
                break;
            case 10656: //Dragonscale Leatherworking
                m_playerTarget->removeSpell(10658, false); //Elemental Leatherworking
                m_playerTarget->removeSpell(10660, false); //Tribal Leatherworking
                break;
            case 10658: //Elemental Leatherworking
                m_playerTarget->removeSpell(10656, false); //Dragonscale Leatherworking
                m_playerTarget->removeSpell(10660, false); //Tribal Leatherworking
                break;
            case 10660: //Tribal Leatherworking
                m_playerTarget->removeSpell(10656, false); //Dragonscale Leatherworking
                m_playerTarget->removeSpell(10658, false); //Elemental Leatherworking
                break;
            case 28677: //Elixir Master
                m_playerTarget->removeSpell(28675, false); //Potion Master
                m_playerTarget->removeSpell(28672, false); //Transmutation Maste
                break;
            case 28675: //Potion Master
                m_playerTarget->removeSpell(28677, false); //Elixir Master
                m_playerTarget->removeSpell(28672, false); //Transmutation Maste
                break;
            case 28672: //Transmutation Master
                m_playerTarget->removeSpell(28675, false); //Potion Master
                m_playerTarget->removeSpell(28677, false); //Elixir Master
                break;
            case 20219: //Gnomish Engineer
                m_playerTarget->removeSpell(20222, false); //Goblin Engineer
                break;
            case 20222: //Goblin Engineer
                m_playerTarget->removeSpell(20219, false); //Gnomish Engineer
                break;
            case 9788: //Armorsmith
                m_playerTarget->removeSpell(9787, false); //Weaponsmith
                m_playerTarget->removeSpell(17039, false); //Master Swordsmith
                m_playerTarget->removeSpell(17040, false); //Master Hammersmith
                m_playerTarget->removeSpell(17041, false); //Master Axesmith
                break;
            case 9787: //Weaponsmith
                m_playerTarget->removeSpell(9788, false); //Armorsmith
                break;
            case 17041: //Master Axesmith
                m_playerTarget->removeSpell(9788, false); //Armorsmith
                m_playerTarget->removeSpell(17040, false); //Master Hammersmith
                m_playerTarget->removeSpell(17039, false); //Master Swordsmith
                break;
            case 17040: //Master Hammersmith
                m_playerTarget->removeSpell(9788, false); //Armorsmith
                m_playerTarget->removeSpell(17039, false); //Master Swordsmith
                m_playerTarget->removeSpell(17041, false); //Master Axesmith
                break;
            case 17039: //Master Swordsmith
                m_playerTarget->removeSpell(9788, false); //Armorsmith
                m_playerTarget->removeSpell(17040, false); //Master Hammersmith
                m_playerTarget->removeSpell(17041, false); //Master Axesmith
                break;
        }
        for (uint8_t j = 0; j < 3; j++)
            if (spellinfo->getEffect(j) == SPELL_EFFECT_WEAPON ||
                spellinfo->getEffect(j) == SPELL_EFFECT_PROFICIENCY ||
                spellinfo->getEffect(j) == SPELL_EFFECT_DUAL_WIELD)
            {
                Spell* sp = sSpellMgr.newSpell(m_unitTarget, spellinfo, true, nullptr);
                SpellCastTargets targets(m_unitTarget->getGuid());
                sp->prepare(&targets);
                break;
            }
        return;
    }
 
    // if we got here... try via pet spells..
    SpellEffectLearnPetSpell(effectIndex);
}

Here is the call graph for this function:

◆ spellEffectMilling()

void Spell::spellEffectMilling ( uint8_t effectIndex )

◆ SpellEffectMilling()

void Spell::SpellEffectMilling ( uint8_t effectIndex )

Definition at line 6130 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster) return;
 
    if (!m_itemTarget) // this should never happen
    {
        sendCastResult(SPELL_FAILED_CANT_BE_PROSPECTED);
        return;
    }
 
    //Fill Prospecting loot
    p_caster->setLootGuid(m_itemTarget->getGuid());
    if (!m_itemTarget->m_loot)
    {
        m_itemTarget->m_loot = std::make_unique<Loot>();
        sLootMgr.fillItemLoot(p_caster, m_itemTarget->m_loot.get(), m_itemTarget->getEntry(), 0);
    }
 
    if (m_itemTarget->m_loot->items.size() > 0)
    {
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Successfully milled item {}", uint32_t(m_itemTarget->getEntry()));
        p_caster->sendLoot(m_itemTarget->getGuid(), LOOT_MILLING, p_caster->GetMapId());
    }
    else // this should never happen either
    {
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Milling failed, item {} has no loot", uint32_t(m_itemTarget->getEntry()));
        sendCastResult(SPELL_FAILED_CANT_BE_PROSPECTED);
    }
}

Here is the call graph for this function:

◆ spellEffectNotImplemented()

void Spell::spellEffectNotImplemented ( uint8_t effectIndex )

Definition at line 489 of file SpellEffects.Legacy.cpp.

{
    sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Spells: Unhandled spell effect {} in spell {}.", getSpellInfo()->getEffect(effIndex), getSpellInfo()->getId());
}

Here is the call graph for this function:

◆ spellEffectNotUsed()

void Spell::spellEffectNotUsed ( uint8_t effectIndex )

Definition at line 494 of file SpellEffects.Legacy.cpp.

{
    // Handled elsewhere or not used, so do nothing
}

◆ spellEffectOpenLock()

void Spell::spellEffectOpenLock ( uint8_t effectIndex )

◆ SpellEffectOpenLock()

void Spell::SpellEffectOpenLock ( uint8_t effectIndex )

Definition at line 3393 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster)
        return;
 
    uint8_t loottype = 0;
 
    uint32_t locktype = getSpellInfo()->getEffectMiscValue(effectIndex);
    switch (locktype)
    {
#if VERSION_STRING <= WotLK
        case LOCKTYPE_PICKLOCK:
        {
            uint32_t v = 0;
            uint32_t lockskill = p_caster->getSkillLineCurrent(SKILL_LOCKPICKING);
 
            if (m_itemTarget)
            {
                if (!m_itemTarget->m_isLocked)
                    return;
 
                auto lock = sLockStore.lookupEntry(m_itemTarget->getItemProperties()->LockId);
                if (!lock)
                    return;
 
                for (uint8_t j = 0; j < LOCK_NUM_CASES; ++j)
                {
                    if (lock->locktype[j] == 2 && lock->minlockskill[j] && lockskill >= lock->minlockskill[j])
                    {
                        v = lock->minlockskill[j];
                        m_itemTarget->m_isLocked = false;
                        m_itemTarget->addFlags(ITEM_FLAG_LOOTABLE);
                        DetermineSkillUp(SKILL_LOCKPICKING, v / 5);
                        break;
                    }
                }
            }
            else if (m_gameObjTarget)
            {
                auto gameobject_info = m_gameObjTarget->GetGameObjectProperties();
                if (m_gameObjTarget->getState() == 0)
                    return;
 
                auto lock = sLockStore.lookupEntry(gameobject_info->raw.parameter_0);
                if (lock == nullptr)
                    return;
 
                for (uint8_t j = 0; j < LOCK_NUM_CASES; ++j)
                {
                    if (lock->locktype[j] == 2 && lock->minlockskill[j] && lockskill >= lock->minlockskill[j])
                    {
                        v = lock->minlockskill[j];
                        m_gameObjTarget->setFlags(GO_FLAG_NONE);
                        m_gameObjTarget->setState(GO_STATE_CLOSED);
                        //Add Fill GO loot here
                        if (m_gameObjTarget->IsLootable())
                        {
                            GameObject_Lootable* pLGO = static_cast<GameObject_Lootable*>(m_gameObjTarget);
                            if (pLGO->loot.items.size() == 0)
                            {
                                if (m_gameObjTarget->getWorldMap() != nullptr)
                                    sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, m_gameObjTarget->getWorldMap()->getDifficulty());
                                else
                                    sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, 0);
 
                                DetermineSkillUp(SKILL_LOCKPICKING, v / 5);     //to prevent free skill up
                            }
                        }
                        loottype = LOOT_CORPSE;
                        //End of it
                        break;
                    }
                }
            }
        }
        break;
#endif
        case LOCKTYPE_HERBALISM:
        {
            if (!m_gameObjTarget) return;
 
            uint32_t v = m_gameObjTarget->GetGOReqSkill();
            bool bAlreadyUsed = false;
 
            if (static_cast<Player*>(m_caster)->getSkillLineCurrent(SKILL_HERBALISM) < v)
            {
                //sendCastResult(SPELL_FAILED_LOW_CASTLEVEL);
                return;
            }
            else
            {
                if (m_gameObjTarget->IsLootable())
                {
                    GameObject_Lootable* pLGO = static_cast<GameObject_Lootable*>(m_gameObjTarget);
 
                    if (pLGO->loot.items.size() == 0)
                    {
                        if (m_gameObjTarget->getWorldMap() != nullptr)
                            sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, m_gameObjTarget->getWorldMap()->getDifficulty());
                        else
                            sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, 0);
                    }
                    else
                    {
                        bAlreadyUsed = true;
                    }
                }
            }
            loottype = LOOT_SKINNING;
 
            //Skill up
            if (!bAlreadyUsed) //Avoid cheats with opening/closing without taking the loot
                DetermineSkillUp(SKILL_HERBALISM, v / 5);
        }
        break;
        case LOCKTYPE_MINING:
        {
            if (!m_gameObjTarget)
                return;
 
            uint32_t v = m_gameObjTarget->GetGOReqSkill();
            bool bAlreadyUsed = false;
 
            if (static_cast<Player*>(m_caster)->getSkillLineCurrent(SKILL_MINING) < v)
            {
                //sendCastResult(SPELL_FAILED_LOW_CASTLEVEL);
                return;
            }
            else if (m_gameObjTarget->IsLootable())
            {
                GameObject_Lootable* pLGO = static_cast<GameObject_Lootable*>(m_gameObjTarget);
                if (pLGO->loot.items.size() == 0)
                {
                    if (m_gameObjTarget->getWorldMap() != nullptr)
                        sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, m_gameObjTarget->getWorldMap()->getDifficulty());
                    else
                        sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, 0);
                }
            }
            else
            {
                bAlreadyUsed = true;
            }
            loottype = LOOT_SKINNING;
 
            //Skill up
            if (!bAlreadyUsed) //Avoid cheats with opening/closing without taking the loot
                DetermineSkillUp(SKILL_MINING, v / 5);
        }
        break;
        case LOCKTYPE_SLOW_OPEN: // used for BG go's
        {
            if (!m_gameObjTarget) return;
            if (p_caster && p_caster->getBattleground())
                if (p_caster->getBattleground()->HookSlowLockOpen(m_gameObjTarget, p_caster, this))
                    return;
 
            uint32_t spellid = !m_gameObjTarget->GetGameObjectProperties()->raw.parameter_10 ? 23932 : m_gameObjTarget->GetGameObjectProperties()->raw.parameter_10;
            SpellInfo const* en = sSpellMgr.getSpellInfo(spellid);
            Spell* sp = sSpellMgr.newSpell(p_caster, en, true, nullptr);
            SpellCastTargets tgt;
            tgt.setGameObjectTarget(m_gameObjTarget->getGuid());
            sp->prepare(&tgt);
            return;
        }
        break;
        case LOCKTYPE_QUICK_CLOSE:
        {
            if (m_gameObjTarget == nullptr)
                return;
 
            m_gameObjTarget->Use(m_caster->getGuid());
        }
        break;
 
        case LOCKTYPE_QUICK_OPEN:
            if (m_gameObjTarget == nullptr)
                return;
 
            if ((p_caster != nullptr) && (p_caster->getBattleground() != nullptr))
                p_caster->getBattleground()->HookQuickLockOpen(m_gameObjTarget, p_caster, this);
 
            // there is no break here on purpose
 
        default://not profession
        {
            if (m_gameObjTarget == nullptr)
                return;
 
            m_gameObjTarget->onUse(m_caster->ToPlayer());
            m_gameObjTarget->Use(m_caster->getGuid());
 
            if (m_gameObjTarget->GetScript())
                m_gameObjTarget->GetScript()->OnActivate(p_caster);
 
            if (m_gameObjTarget->getWorldMap() && m_gameObjTarget->getWorldMap()->getScript())
                m_gameObjTarget->getWorldMap()->getScript()->OnGameObjectActivate(m_gameObjTarget, p_caster);
 
            if (sQuestMgr.OnActivateQuestGiver(m_gameObjTarget, p_caster))
                return;
 
            if (sQuestMgr.OnGameObjectActivate(p_caster, m_gameObjTarget))
            {
                p_caster->updateNearbyQuestGameObjects();
                return;
            }
 
            if (m_gameObjTarget->IsLootable())
            {
                GameObject_Lootable* pLGO = static_cast<GameObject_Lootable*>(m_gameObjTarget);
 
                if (pLGO->loot.items.size() == 0)
                {
                    if (m_gameObjTarget->getWorldMap() != nullptr)
                        sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, m_gameObjTarget->getWorldMap()->getDifficulty());
                    else
                        sLootMgr.fillGOLoot(p_caster, &pLGO->loot, m_gameObjTarget->GetGameObjectProperties()->raw.parameter_1, 0);
                }
            }
            loottype = LOOT_CORPSE;
        }
        break;
    };
    if (m_gameObjTarget && m_gameObjTarget->getGoType() == GAMEOBJECT_TYPE_CHEST)
        static_cast< Player* >(m_caster)->sendLoot(m_gameObjTarget->getGuid(), loottype, m_gameObjTarget->GetMapId());
}

Here is the call graph for this function:

◆ spellEffectOpenLockItem()

void Spell::spellEffectOpenLockItem ( uint8_t effectIndex )

◆ SpellEffectOpenLockItem()

void Spell::SpellEffectOpenLockItem ( uint8_t effectIndex )

Definition at line 4329 of file SpellEffects.Legacy.cpp.

{
    if (p_caster == nullptr || i_caster == nullptr)
        return;
 
    p_caster->handleSpellLoot(i_caster->getItemProperties()->ItemId);
}

Here is the call graph for this function:

◆ spellEffectParry()

void Spell::spellEffectParry ( uint8_t effectIndex )

◆ SpellEffectParry()

void Spell::SpellEffectParry ( uint8_t effectIndex )

Definition at line 2491 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget)
        m_unitTarget->setcanparry(true);
}

Here is the call graph for this function:

◆ spellEffectPersistentAA()

void Spell::spellEffectPersistentAA ( uint8_t effectIndex )

◆ SpellEffectPersistentAA()

void Spell::SpellEffectPersistentAA ( uint8_t effectIndex )

Definition at line 2738 of file SpellEffects.Legacy.cpp.

{
    if (m_AreaAura || !m_caster->IsInWorld())
        return;
    //create only 1 dyn object
    uint32_t dur = getDuration();
    float r = getEffectRadius(effectIndex);
 
    //Note: this code seems to be useless
    //this must be only source point or dest point
    //this AREA aura it's applied on area
    //it can'be on unit or self or item or object
    //uncomment it if I'm wrong
    //We are thinking in general so it might be useful later DK
 
    // grep: this is a hack!
    // our shitty dynobj system doesn't support GO casters, so we gotta
    // kinda have 2 summoners for traps that apply AA.
    DynamicObject* dynObj = m_caster->getWorldMap()->createDynamicObject();
 
    if (g_caster != nullptr && g_caster->getUnitOwner() && !m_unitTarget)
    {
        Unit* caster = g_caster->getUnitOwner();
        dynObj->create(caster, this, g_caster->GetPosition(), dur, r, DYNAMIC_OBJECT_AREA_SPELL);
        m_AreaAura = true;
        return;
    }
 
    switch (m_targets.getTargetMask())
    {
        case TARGET_FLAG_SELF:
        {
            dynObj->create(u_caster, this, m_caster->GetPosition(), dur, r, DYNAMIC_OBJECT_AREA_SPELL);
        }
        break;
        case TARGET_FLAG_UNIT:
        {
            if (!m_unitTarget || !m_unitTarget->isAlive())
            {
                dynObj->remove();
                return;
            }
 
            dynObj->create(u_caster, this, m_unitTarget->GetPosition(), dur, r, DYNAMIC_OBJECT_AREA_SPELL);
        }
        break;
        case TARGET_FLAG_OBJECT:
        {
            if (!m_unitTarget || !m_unitTarget->isAlive())
            {
                dynObj->remove();
                return;
            }
 
            dynObj->create(u_caster, this, m_unitTarget->GetPosition(), dur, r, DYNAMIC_OBJECT_AREA_SPELL);
        }
        break;
        case TARGET_FLAG_SOURCE_LOCATION:
        {
            auto source = m_targets.getSource();
            dynObj->create(u_caster, this, source, dur, r, DYNAMIC_OBJECT_AREA_SPELL);
        }
        break;
        case TARGET_FLAG_DEST_LOCATION:
        {
            auto destination = m_targets.getDestination();
            if (u_caster != nullptr)
                dynObj->create(u_caster, this, destination, dur, r, DYNAMIC_OBJECT_AREA_SPELL);
            else if (g_caster != nullptr)
                dynObj->create(g_caster->getUnitOwner(), this, destination, dur, r, DYNAMIC_OBJECT_AREA_SPELL);
        }
        break;
        default:
            dynObj->remove();
            return;
    }
 
    if (u_caster)
        if (getSpellInfo()->getChannelInterruptFlags() > 0)
        {
            u_caster->setChannelObjectGuid(dynObj->getGuid());
            u_caster->setChannelSpellId(getSpellInfo()->getId());
        }
 
    m_AreaAura = true;
}

Here is the call graph for this function:

◆ spellEffectPickpocket()

void Spell::spellEffectPickpocket ( uint8_t effectIndex )

◆ SpellEffectPickpocket()

void Spell::SpellEffectPickpocket ( uint8_t effectIndex )

Definition at line 4549 of file SpellEffects.Legacy.cpp.

{
    //Show random loot based on roll,
    if (!m_unitTarget || !p_caster || !m_unitTarget->isCreature())
        return;
 
    Creature* target = static_cast< Creature* >(m_unitTarget);
    if (target->IsPickPocketed() || (target->GetCreatureProperties()->Type != UNIT_TYPE_HUMANOID))
    {
        sendCastResult(SPELL_FAILED_TARGET_NO_POCKETS);
        return;
    }
 
    sLootMgr.fillPickpocketingLoot(p_caster, &m_unitTarget->loot, m_unitTarget->getEntry(), 0);
 
    uint32_t _rank = static_cast< Creature* >(m_unitTarget)->GetCreatureProperties()->Rank;
    m_unitTarget->loot.gold = Util::float2int32((_rank + 1) * m_unitTarget->getLevel() * (Util::getRandomUInt(5) + 1) * worldConfig.getFloatRate(RATE_MONEY));
 
    p_caster->sendLoot(m_unitTarget->getGuid(), LOOT_PICKPOCKETING, m_unitTarget->GetMapId());
    target->SetPickPocketed(true);
}

Here is the call graph for this function:

◆ spellEffectPlayerPull()

void Spell::spellEffectPlayerPull ( uint8_t effectIndex )

◆ SpellEffectPlayerPull()

void Spell::SpellEffectPlayerPull ( uint8_t effectIndex )

Definition at line 5810 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive() || !m_unitTarget->isPlayer())
        return;
 
    Player* p_target = static_cast< Player* >(m_unitTarget);
 
    // calculate destination
    float pullD = p_target->CalcDistance(m_caster) - p_target->getBoundingRadius() - (u_caster ? u_caster->getBoundingRadius() : 0) - 1.0f;
    float pullO = p_target->calcRadAngle(p_target->GetPositionX(), p_target->GetPositionY(), m_caster->GetPositionX(), m_caster->GetPositionY());
    float pullX = p_target->GetPositionX() + pullD * cosf(pullO);
    float pullY = p_target->GetPositionY() + pullD * sinf(pullO);
    float pullZ = m_caster->GetPositionZ() + 0.3f;
    uint32_t time = uint32_t(pullD * 42.0f);
 
    p_target->SetOrientation(pullO);
 
    WorldPacket data(SMSG_MONSTER_MOVE, 60);
    data << p_target->GetNewGUID();
    data << uint8_t(0);
    data << p_target->GetPositionX();
    data << p_target->GetPositionY();
    data << p_target->GetPositionZ();
    data << Util::getMSTime();
    data << uint8_t(4);
    data << pullO;
    data << uint32_t(0x00001000);
    data << time;
    data << uint32_t(1);
    data << pullX;
    data << pullY;
    data << pullZ;
 
    p_target->sendMessageToSet(&data, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectPlayMusic()

void Spell::spellEffectPlayMusic ( uint8_t effectIndex )

◆ SpellEffectPlayMusic()

void Spell::SpellEffectPlayMusic ( uint8_t effectIndex )

Definition at line 5967 of file SpellEffects.Legacy.cpp.

{
    uint32_t soundid = m_spellInfo->getEffectMiscValue(effectIndex);
 
    if (soundid == 0)
    {
        sLogger.failure("Spell {} ({}) has no sound ID to play. Spell needs fixing!", m_spellInfo->getId(), m_spellInfo->getName());
        return;
    }
 
    m_caster->PlaySoundToSet(soundid);
}

Here is the call graph for this function:

◆ spellEffectPowerBurn()

void Spell::spellEffectPowerBurn ( uint8_t effectIndex )

◆ SpellEffectPowerBurn()

void Spell::SpellEffectPowerBurn ( uint8_t effectIndex )

Definition at line 4351 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isAlive() || m_unitTarget->getPowerType() != POWER_TYPE_MANA)
        return;
 
    if (m_unitTarget->isPlayer())
    {
        Player* mPlayer = static_cast< Player* >(m_unitTarget);
        if (mPlayer->isInFeralForm())
            return;
 
        // Resilience - reduces the effect of mana drains by (CalcRating*2)%.
        damage = Util::float2int32(damage * (1 - ((static_cast< Player* >(m_unitTarget)->calcRating(CR_CRIT_TAKEN_SPELL) * 2) / 100.0f)));
    }
    int32_t mult = damage;
    damage = mult * m_unitTarget->getMaxPower(POWER_TYPE_MANA) / 100;
    if (m_caster->isCreatureOrPlayer())  //Spell ctor has ASSERT(m_caster != NULL) so there's no need to add NULL checks, even if static analysis reports them.
    {
        Unit* caster = static_cast< Unit* >(m_caster);
        if ((uint32_t)damage > caster->getMaxPower(POWER_TYPE_MANA) * (mult * 2) / 100)
            damage = caster->getMaxPower(POWER_TYPE_MANA) * (mult * 2) / 100;
    }
 
    int32_t mana = std::min((int32_t)m_unitTarget->getPower(POWER_TYPE_MANA), damage);
 
    m_unitTarget->modPower(POWER_TYPE_MANA, -mana);
 
    m_targetDamageInfo = m_caster->doSpellDamage(m_unitTarget, getSpellInfo()->getId(), mana * getSpellInfo()->getEffectMultipleValue(effectIndex), effectIndex, m_triggeredSpell, false, false, isForcedCrit, this);
    isTargetDamageInfoSet = true;
}

Here is the call graph for this function:

◆ spellEffectPowerDrain()

void Spell::spellEffectPowerDrain ( uint8_t effectIndex )

◆ SpellEffectPowerDrain()

void Spell::SpellEffectPowerDrain ( uint8_t effectIndex )

Definition at line 1982 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    auto powerField = static_cast<PowerType>(getSpellInfo()->getEffectMiscValue(effectIndex));
    auto curPower = m_unitTarget->getPower(powerField);
    if (powerField == POWER_TYPE_MANA && m_unitTarget->isPlayer())
    {
        Player* mPlayer = static_cast< Player* >(m_unitTarget);
        if (mPlayer->isInFeralForm())
            return;
 
        // Resilience - reduces the effect of mana drains by (CalcRating*2)%.
        damage = Util::float2int32(damage * (1 - ((static_cast< Player* >(m_unitTarget)->calcRating(CR_CRIT_TAKEN_SPELL) * 2) / 100.0f)));
    }
    uint32_t amt = damage + ((u_caster->GetDamageDoneMod(getSpellInfo()->getFirstSchoolFromSchoolMask()) * 80) / 100);
    if (amt > curPower)
        amt = curPower;
    m_unitTarget->setPower(powerField, curPower - amt);
    u_caster->energize(u_caster, getSpellInfo()->getId(), amt, powerField);
}

Here is the call graph for this function:

◆ spellEffectPowerFunnel()

void Spell::spellEffectPowerFunnel ( uint8_t effectIndex )

◆ SpellEffectPowerFunnel()

void Spell::SpellEffectPowerFunnel ( uint8_t effectIndex )

Definition at line 4420 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive() || !m_unitTarget->isPet())
        return;
 
    //does not exist
}

Here is the call graph for this function:

◆ spellEffectProficiency()

void Spell::spellEffectProficiency ( uint8_t effectIndex )

Definition at line 622 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
        return;
 
    m_playerTarget->applyItemProficienciesFromSpell(getSpellInfo(), true);
}

Here is the call graph for this function:

◆ spellEffectProspecting()

void Spell::spellEffectProspecting ( uint8_t effectIndex )

◆ SpellEffectProspecting()

void Spell::SpellEffectProspecting ( uint8_t effectIndex )

Definition at line 5913 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster) return;
 
    if (!m_itemTarget) // this should never happen
    {
        sendCastResult(SPELL_FAILED_CANT_BE_PROSPECTED);
        return;
    }
 
    //Fill Prospecting loot
    p_caster->setLootGuid(m_itemTarget->getGuid());
    if (!m_itemTarget->m_loot)
    {
        m_itemTarget->m_loot = std::make_unique<Loot>();
        sLootMgr.fillItemLoot(p_caster, m_itemTarget->m_loot.get(), m_itemTarget->getEntry(), 0);
    }
 
    if (m_itemTarget->m_loot->items.size() > 0)
    {
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Successfully prospected item {}", uint32_t(m_itemTarget->getEntry()));
        p_caster->sendLoot(m_itemTarget->getGuid(), LOOT_PROSPECTING, p_caster->GetMapId());
    }
    else // this should never happen either
    {
        sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Prospecting failed, item {} has no loot", uint32_t(m_itemTarget->getEntry()));
        sendCastResult(SPELL_FAILED_CANT_BE_PROSPECTED);
    }
}

Here is the call graph for this function:

◆ SpellEffectPullTowardsDest()

void Spell::SpellEffectPullTowardsDest ( uint8_t effectIndex )

Definition at line 5044 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget)
        return;
 
    if (!m_targets.hasDestination())
    {
        sLogger.failure("Spell {} with SPELL_EFFECT_PULL_TOWARDS_DEST has no dest target", m_spellInfo->getId());
        return;
    }
 
    LocationVector pos = m_targets.getDestination();
    // This is a blizzlike mistake: this should be 2D distance according to projectile motion formulas, but Blizzard erroneously used 3D distance
    float distXY = m_unitTarget->getExactDist(pos);
 
    // Avoid division by 0
    if (distXY < 0.001)
        return;
 
    float distZ = pos.getPositionZ() - m_unitTarget->GetPositionZ();
 
    float speedXY = m_spellInfo->getEffectMiscValue(effIndex) ? m_spellInfo->getEffectMiscValue(effIndex) / 10.0f : 30.0f;
    float speedZ = (2 * speedXY * speedXY * distZ + MovementMgr::gravity * distXY * distXY) / (2 * speedXY * distXY);
 
    if (!std::isfinite(speedZ))
    {
        sLogger.failure("Spell {} with SPELL_EFFECT_PULL_TOWARDS_DEST called with invalid speedZ.", m_spellInfo->getId());
        return;
    }
 
    m_unitTarget->jumpTo(speedXY, speedZ, true, pos);
}

Here is the call graph for this function:

◆ spellEffectQuestComplete()

void Spell::spellEffectQuestComplete ( uint8_t effectIndex )

◆ SpellEffectQuestComplete()

void Spell::SpellEffectQuestComplete ( uint8_t effectIndex )

Definition at line 2397 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster)
        return;
 
    if (auto* questLog = p_caster->getQuestLogByQuestId(getSpellInfo()->getEffectMiscValue(effectIndex)))
    {
        questLog->setStateComplete();
        questLog->updatePlayerFields();
        questLog->sendQuestComplete();
    }
}

Here is the call graph for this function:

◆ spellEffectRedirectThreat()

void Spell::spellEffectRedirectThreat ( uint8_t effectIndex )

◆ SpellEffectRedirectThreat()

void Spell::SpellEffectRedirectThreat ( uint8_t effectIndex )

Definition at line 5953 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster || !m_unitTarget)
        return;
 
    if ((m_unitTarget->isPlayer() && p_caster->getGroup() != static_cast< Player* >(m_unitTarget)->getGroup()) || (m_unitTarget->isCreature() && !m_unitTarget->isPet()))
        return;
 
    p_caster->setMisdirectionTarget(m_unitTarget->getGuid());
 
    // Threat Management
    p_caster->getThreatManager().registerRedirectThreat(m_spellInfo->getId(), m_unitTarget->getGuid(), uint32_t(damage));
}

Here is the call graph for this function:

◆ spellEffectReduceThreatPercent()

void Spell::spellEffectReduceThreatPercent ( uint8_t effectIndex )

◆ SpellEffectReduceThreatPercent()

void Spell::SpellEffectReduceThreatPercent ( uint8_t effectIndex )

Definition at line 5846 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isCreature() || !u_caster || m_unitTarget->getThreatManager().getThreat(u_caster) == 0)
        return;
 
    m_unitTarget->getThreatManager().modifyThreatByPercent(u_caster, (int32_t)m_unitTarget->getThreatManager().getThreat(u_caster) * damage / 100);
}

Here is the call graph for this function:

◆ spellEffectRenamePet()

void Spell::spellEffectRenamePet ( uint8_t effectIndex )

◆ SpellEffectRenamePet()

void Spell::SpellEffectRenamePet ( uint8_t effectIndex )

Definition at line 6160 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isPet() ||
        !static_cast< Pet* >(m_unitTarget)->getPlayerOwner() || static_cast< Pet* >(m_unitTarget)->getPlayerOwner()->getClass() != HUNTER)
        return;
 
#if VERSION_STRING == Classic
    m_unitTarget->addUnitFlags(UNIT_FLAG_PET_CAN_BE_RENAMED);
#else
    m_unitTarget->addPetFlags(PET_FLAG_CAN_BE_RENAMED);
#endif
}

Here is the call graph for this function:

◆ spellEffectReputation()

void Spell::spellEffectReputation ( uint8_t effectIndex )

◆ SpellEffectReputation()

void Spell::SpellEffectReputation ( uint8_t effectIndex )

Definition at line 5178 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget)
        return;
 
    m_playerTarget->modFactionStanding(getSpellInfo()->getEffectMiscValue(effectIndex), damage);
}

Here is the call graph for this function:

◆ spellEffectRestoreHealthPct()

void Spell::spellEffectRestoreHealthPct ( uint8_t effectIndex )

◆ SpellEffectRestoreHealthPct()

void Spell::SpellEffectRestoreHealthPct ( uint8_t effectIndex )

Definition at line 6173 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isAlive())
        return;
 
    m_unitTarget->addSimpleHealingBatchEvent(Util::float2int32(damage * m_unitTarget->getMaxHealth() / 100.0f), u_caster, pSpellId != 0 ? sSpellMgr.getSpellInfo(pSpellId) : getSpellInfo());
}

Here is the call graph for this function:

◆ spellEffectRestorePowerPct()

void Spell::spellEffectRestorePowerPct ( uint8_t effectIndex )

◆ SpellEffectRestorePowerPct()

void Spell::SpellEffectRestorePowerPct ( uint8_t effectIndex )

Definition at line 5997 of file SpellEffects.Legacy.cpp.

{
    if (u_caster == nullptr || m_unitTarget == nullptr || !m_unitTarget->isAlive())
        return;
 
    auto power_type = static_cast<PowerType>(getSpellInfo()->getEffectMiscValue(effectIndex));
    if (power_type >= TOTAL_PLAYER_POWER_TYPES)
    {
        sLogger.failure("Unhandled power type {} in {}, report this line to devs.", power_type, __FUNCTION__);
        return;
    }
 
    uint32_t amount = damage * m_unitTarget->getMaxPower(power_type) / 100;
    u_caster->energize(m_unitTarget, getSpellInfo()->getId(), amount, power_type);
}

Here is the call graph for this function:

◆ spellEffectResurrect()

void Spell::spellEffectResurrect ( uint8_t effectIndex )

◆ SpellEffectResurrect()

void Spell::SpellEffectResurrect ( uint8_t effectIndex )

Definition at line 2420 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget)
    {
        if (!m_corpseTarget)
        {
            // unit resurrection handler
            if (m_unitTarget)
            {
                if (m_unitTarget->isCreature() && m_unitTarget->isPet() && m_unitTarget->isDead())
                {
                    uint32_t hlth = ((uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex) > m_unitTarget->getMaxHealth()) ? m_unitTarget->getMaxHealth() : (uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex);
                    uint32_t mana = ((uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex) > m_unitTarget->getMaxPower(POWER_TYPE_MANA)) ? m_unitTarget->getMaxPower(POWER_TYPE_MANA) : (uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex);
 
                    if (!m_unitTarget->isPet())
                    {
                        sEventMgr.RemoveEvents(m_unitTarget, EVENT_CREATURE_REMOVE_CORPSE);
                    }
                    else
                    {
                        sEventMgr.RemoveEvents(m_unitTarget, EVENT_PET_DELAYED_REMOVE);
                        sEventMgr.RemoveEvents(m_unitTarget, EVENT_CREATURE_REMOVE_CORPSE);
                    }
                    m_unitTarget->setHealth(hlth);
                    m_unitTarget->setPower(POWER_TYPE_MANA, mana);
                    m_unitTarget->setTaggerGuid(nullptr);
                    m_unitTarget->setDeathState(ALIVE);
                    m_unitTarget->loot.clear();
                    static_cast< Creature* >(m_unitTarget)->SetLimboState(false); // we can regenerate health now
                }
            }
 
            return;
        }
 
        WoWGuid wowGuid;
        wowGuid.Init(m_corpseTarget->getOwnerGuid());
 
        m_playerTarget = sObjectMgr.getPlayer(wowGuid.getGuidLowPart());
        if (!m_playerTarget) return;
    }
 
    if (m_playerTarget->isAlive() || !m_playerTarget->IsInWorld())
        return;
 
    uint32_t health = getSpellInfo()->getEffectBasePoints(effectIndex);
    uint32_t mana = getSpellInfo()->getEffectMiscValue(effectIndex);
 
    m_playerTarget->setResurrectHealth(health);
    m_playerTarget->setResurrectMana(mana);
 
    SendResurrectRequest(m_playerTarget);
    m_playerTarget->setMoveRoot(false);
}

Here is the call graph for this function:

◆ spellEffectResurrectNew()

void Spell::spellEffectResurrectNew ( uint8_t effectIndex )

◆ SpellEffectResurrectNew()

void Spell::SpellEffectResurrectNew ( uint8_t effectIndex )

Definition at line 5361 of file SpellEffects.Legacy.cpp.

{
    //base p =hp,misc mana
    if (!m_playerTarget)
    {
        if (!m_corpseTarget)
        {
            // unit resurrection handler
            if (m_unitTarget)
            {
                if (m_unitTarget->isCreature() && m_unitTarget->isPet() && m_unitTarget->isDead())
                {
                    uint32_t hlth = ((uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex) > m_unitTarget->getMaxHealth()) ? m_unitTarget->getMaxHealth() : (uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex);
                    uint32_t mana = ((uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex) > m_unitTarget->getMaxPower(POWER_TYPE_MANA)) ? m_unitTarget->getMaxPower(POWER_TYPE_MANA) : (uint32_t)getSpellInfo()->getEffectBasePoints(effectIndex);
 
                    if (!m_unitTarget->isPet())
                    {
                        sEventMgr.RemoveEvents(m_unitTarget, EVENT_CREATURE_REMOVE_CORPSE);
                    }
                    else
                    {
                        sEventMgr.RemoveEvents(m_unitTarget, EVENT_PET_DELAYED_REMOVE);
                        sEventMgr.RemoveEvents(m_unitTarget, EVENT_CREATURE_REMOVE_CORPSE);
                    }
                    m_unitTarget->setHealth(hlth);
                    m_unitTarget->setPower(POWER_TYPE_MANA, mana);
                    m_unitTarget->setTaggerGuid(nullptr);
                    m_unitTarget->setDeathState(ALIVE);
                    m_unitTarget->loot.clear();
                }
            }
 
            return;
        }
 
        WoWGuid wowGuid;
        wowGuid.Init(m_corpseTarget->getOwnerGuid());
 
        m_playerTarget = sObjectMgr.getPlayer(wowGuid.getGuidLowPart());
        if (!m_playerTarget) return;
    }
 
    if (m_playerTarget->isAlive() || !m_playerTarget->IsInWorld())
        return;
    //resurrect
    m_playerTarget->setResurrectMapId(p_caster->GetMapId());
    m_playerTarget->setResurrectInstanceId(p_caster->GetInstanceID());
    m_playerTarget->setResurrectPosition(p_caster->GetPosition());
    m_playerTarget->setResurrectHealth(damage);
    m_playerTarget->setResurrectMana(getSpellInfo()->getEffectMiscValue(effectIndex));
 
    SendResurrectRequest(m_playerTarget);
}

Here is the call graph for this function:

◆ spellEffectSanctuary()

void Spell::spellEffectSanctuary ( uint8_t effectIndex )

◆ SpellEffectSanctuary()

void Spell::SpellEffectSanctuary ( uint8_t effectIndex )

Definition at line 4696 of file SpellEffects.Legacy.cpp.

{
    if (!u_caster)
        return;
 
    if (p_caster != nullptr)
        p_caster->removeAllAurasByAuraEffect(SPELL_AURA_MOD_ROOT);
 
    for (const auto& itr : u_caster->getInRangeObjectsSet())
    {
        if (itr && itr->isCreature())
            static_cast<Creature*>(itr)->getThreatManager().clearThreat(m_unitTarget);
    }
}

Here is the call graph for this function:

◆ spellEffectSchoolDMG()

void Spell::spellEffectSchoolDMG ( uint8_t effectIndex )

◆ SpellEffectSchoolDMG()

void Spell::SpellEffectSchoolDMG ( uint8_t effectIndex )

Definition at line 917 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive())
        return;
 
    if (m_unitTarget->m_schoolImmunityList[getSpellInfo()->getFirstSchoolFromSchoolMask()])
    {
        sendCastResult(SPELL_FAILED_IMMUNE);
        return;
    }
 
    uint32_t dmg = damage;
    bool static_damage = false;
    bool force_crit = false;
 
    if (getSpellInfo()->getEffectChainTarget(effectIndex))    //chain
    {
        if (getSpellInfo()->getId() == 32445 || getSpellInfo()->getId() == 28883)
        {
            int32_t reduce = (int32_t)(getSpellInfo()->getEffectDamageMultiplier(effectIndex) * 100.0f);
            reduce -= 100;
 
            if (reduce && chaindamage)
            {
                if (u_caster != nullptr)
                {
                    u_caster->applySpellModifiers(SPELLMOD_JUMP_REDUCE, &reduce, getSpellInfo(), this);
                }
                chaindamage += ((getSpellInfo()->getEffectBasePoints(effectIndex) + 51) * reduce / 100);
            }
            else
            {
                chaindamage = dmg;
            }
            dmg = chaindamage;
        }
        else
        {
            int32_t reduce = (int32_t)(getSpellInfo()->getEffectDamageMultiplier(effectIndex) * 100.0f);
 
            if (reduce && chaindamage)
            {
                if (u_caster != nullptr)
                {
                    u_caster->applySpellModifiers(SPELLMOD_JUMP_REDUCE, &reduce, getSpellInfo(), this);
                }
                chaindamage = chaindamage * reduce / 100;
            }
            else
            {
                chaindamage = dmg;
            }
            dmg = chaindamage;
        }
    }
    else
    {
        switch (getSpellInfo()->getId())
        {
            // SPELL_HASH_METEOR_SLASH:
            case 45150:
            {
                uint32_t splitCount = 0;
                for (const auto& itr : u_caster->getInRangeOppositeFactionSet())
                {
                    if (itr && itr->isInFront(u_caster) && u_caster->CalcDistance(itr) <= 65)
                        splitCount++;
                }
 
                if (splitCount > 1)
                    dmg = dmg / splitCount;
            } break;
 
            // SPELL_HASH_PULSING_SHOCKWAVE: // loken Pulsing shockwave
            case 52942:
            case 52961:
            case 59836:
            case 59837:
            {
                float _distance = u_caster->CalcDistance(m_unitTarget);
                if (_distance >= 2.0f)
                    dmg = static_cast<uint32_t>(dmg * _distance);
            } break;
 
            // SPELL_HASH_INCINERATE: // Incinerate -> Deals x-x extra damage if the target is affected by immolate
            case 19397:
            case 23308:
            case 23309:
            case 29722:
            case 32231:
            case 32707:
            case 36832:
            case 38401:
            case 38918:
            case 39083:
            case 40239:
            case 41960:
            case 43971:
            case 44519:
            case 46043:
            case 47837:
            case 47838:
            case 53493:
            case 69973:
            case 71135:
            {
                if (m_unitTarget->hasAuraState(AURASTATE_FLAG_CONFLAGRATE, getSpellInfo(), u_caster))
                {
                    // random extra damage
                    const uint8_t spellRank = getSpellInfo()->hasSpellRanks() ? getSpellInfo()->getRankInfo()->getRank() : 1;
                    uint32_t extra_dmg = 111 + (spellRank * 11) + Util::getRandomUInt(spellRank * 11);
                    dmg += extra_dmg;
                }
            } break;
 
            // SPELL_HASH_ARCANE_SHOT: //hunter - arcane shot
            case 3044:
            case 14281:
            case 14282:
            case 14283:
            case 14284:
            case 14285:
            case 14286:
            case 14287:
            case 27019:
            case 34829:
            case 35401:
            case 36293:
            case 36609:
            case 36623:
            case 38807:
            case 49044:
            case 49045:
            case 51742:
            case 55624:
            case 58973:
            case 69989:
            case 71116:
            {
                if (u_caster)
                    dmg += Util::float2int32(u_caster->getCalculatedRangedAttackPower() * 0.15f);
                dmg = Util::float2int32(dmg * (0.9f + Util::getRandomFloat(0.2f)));      // randomized damage
 
                if (p_caster != nullptr)
                {
                    dmg = static_cast<uint32_t>(std::round((p_caster->getCalculatedRangedAttackPower() * 0.15) + m_spellInfo->getEffectBasePoints(effectIndex)));
                }
            } break;
 
            // SPELL_HASH_GORE: // boar/ravager: Gore (50% chance of double damage)
            case 4102:
            case 32019:
            case 35290:
            case 35291:
            case 35292:
            case 35293:
            case 35294:
            case 35295:
            case 35299:
            case 35300:
            case 35302:
            case 35303:
            case 35304:
            case 35305:
            case 35306:
            case 35307:
            case 35308:
            case 48130:
            case 51751:
            case 59264:
            {
                dmg *= Util::checkChance(50) ? 2 : 1;
            } break;
 
            // SPELL_HASH_THUNDER_CLAP: // Thunderclap
            case 6343:
            case 8198:
            case 8204:
            case 8205:
            case 11580:
            case 11581:
            case 13532:
            case 25264:
            case 47501:
            case 47502:
            case 57832:
            case 60019:
            {
                if (u_caster)
                    dmg = (getSpellInfo()->calculateEffectValue(0)) + Util::float2int32(u_caster->getCalculatedAttackPower() * 0.12f);
            } break;
 
            // SPELL_HASH_SHOCKWAVE:      // Shockwave
            case 25425:
            case 33686:
            case 46968:
            case 55636:
            case 55918:
            case 57728:
            case 57741:
            case 58947:
            case 58977:
            case 63783:
            case 63982:
            case 72149:
            case 73499:
            case 73794:
            case 73795:
            case 73796:
            case 75343:
            case 75417:
            case 75418:
            {
                if (u_caster)
                    dmg = u_caster->getCalculatedAttackPower() * (getSpellInfo()->calculateEffectValue(2)) / 100;
            } break;
 
            // SPELL_HASH_JUDGEMENT_OF_COMMAND:
            case 20425:
            case 20467:
            {
                if (p_caster != nullptr)
                {
                    if (!m_unitTarget->isStunned())
                        dmg = dmg >> 1;
                    if (p_caster->hasAurasWithId(34258))
                        p_caster->castSpell(p_caster, 34260, true);
                    if ((p_caster->hasAurasWithId(53696) || p_caster->hasAurasWithId(53695)))
                        p_caster->castSpell(p_caster, 68055, true);
                    if (p_caster->hasAurasWithId(37186))
                        dmg = 33;
                }
            } break;
            case 29386:
            case 32778:
            case 33554:
            case 41368:
            case 41470:
            case 66005:
            case 68017:
            case 68018:
            case 68019:
            case 71551:
            {
                if (!m_unitTarget->isStunned())
                    dmg = dmg >> 1;
            } break;
 
            // SPELL_HASH_FIRE_STRIKE:
            case 7712:
            case 7714:
            case 7715:
            case 7716:
            case 7717:
            case 7718:
            case 7719:
            // SPELL_HASH_LIGHTNING_STRIKE:
            case 16614:
            case 23686:
            case 23687:
            case 27983:
            case 37841:
            case 52944:
            case 53062:
            // SPELL_HASH_MOLTEN_ARMOR:       // fire armor, is static damage
            case 30482:
            case 34913:
            case 35915:
            case 35916:
            case 43043:
            case 43044:
            case 43045:
            case 43046:
            {
                static_damage = true;
            } break;
 
            // SPELL_HASH_EXORCISM:
            case 879:
            case 5614:
            case 5615:
            case 10312:
            case 10313:
            case 10314:
            case 17147:
            case 17149:
            case 27138:
            case 33632:
            case 48800:
            case 48801:
            case 52445:
            case 58822:
            {
                if (p_caster != nullptr)
                {
                    uint32_t sph = p_caster->getModDamageDonePositive(SCHOOL_HOLY);
                    int32_t ap = p_caster->getCalculatedAttackPower();
                    dmg += Util::float2int32((0.15f * sph) + (0.15f * ap));
                    if (m_unitTarget && m_unitTarget->isCreature())
                    {
                        uint32_t type = static_cast<Creature*>(m_unitTarget)->GetCreatureProperties()->Type;
                        if (type == UNIT_TYPE_UNDEAD || type == UNIT_TYPE_DEMON)
                            force_crit = true;
                    }
                }
            } break;
 
            // SPELL_HASH_SHIELD_OF_RIGHTEOUSNESS: // Shield of Righteousness - a bit like "shield slam", OK for both ranks
            case 53600:
            case 61411:
            {
                if (p_caster != nullptr)
                {
#if VERSION_STRING != Classic
                    Item* it = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_OFFHAND);
                    if (it && it->getItemProperties() && it->getItemProperties()->InventoryType == INVTYPE_SHIELD)
                        dmg = Util::float2int32(1.3f * p_caster->getShieldBlock());
#else
                    dmg += Util::float2int32(1.30f * p_caster->getCombatRating(CR_BLOCK) + getSpellInfo()->getEffectBasePoints(0));
#endif
                }
            } break;
 
            //SPELL_HASH_CONFLAGRATE
            case 17962:
                m_unitTarget->removeAuraStateAndAuras(AURASTATE_FLAG_CONFLAGRATE);
                break;
 
            //SPELL_HASH_ICE_LANCE
            case 30455:
            case 31766:
            case 42913:
            case 42914:
            case 43427:
            case 43571:
            case 44176:
            case 45906:
            case 46194:
            case 49906:
            case 54261:
            {
                // Deal triple damage to frozen targets or to those in Deep Freeze
                if (m_unitTarget->hasAuraState(AURASTATE_FLAG_FROZEN, getSpellInfo(), u_caster) || m_unitTarget->hasAurasWithId(44572))
                    dmg *= 3;
            } break;
 
            //SPELL_HASH_HEROIC_THROW
            case 57755:
            {
                if (u_caster)
                    dmg = u_caster->getCalculatedAttackPower() / 2 + 12;
                if (p_caster != nullptr)
                    dmg = static_cast<uint32_t>(std::round(p_caster->getCalculatedAttackPower() * 0.5));
            } break;
 
            //SPELL_HASH_SHIELD_SLAM
            case 8242:
            case 15655:
            case 23922:
            case 23923:
            case 23924:
            case 23925:
            case 25258:
            case 29684:
            case 30356:
            case 30688:
            case 46762:
            case 47487:
            case 47488:
            case 49863:
            case 59142:
            case 69903:
            case 72645:
            {
                if (p_caster != nullptr)
                {
                    Item* it = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_OFFHAND);
                    if (it && it->getItemProperties()->InventoryType == INVTYPE_SHIELD)
                    {
                        float block_multiplier = (100.0f + p_caster->m_modBlockAbsorbValue) / 100.0f;
                        if (block_multiplier < 1.0f)block_multiplier = 1.0f;
 
                        int32_t blockable_damage = Util::float2int32((it->getItemProperties()->Block + p_caster->m_modBlockValueFromSpells + p_caster->getCombatRating(CR_BLOCK) + ((p_caster->getStat(STAT_STRENGTH) / 2.0f) - 1.0f)) * block_multiplier);
 
                        /*
                        3.2.0:
                        The benefit from additional block value this ability gains is now subject
                        to diminishing returns. Diminishing returns occur once block value exceeds
                        30 times the player's level and caps the maximum damage benefit from shield
                        block value at 34.5 times the player's level.
                        */
                        int32_t max_blockable_damage = static_cast<int32_t>(p_caster->getLevel() * 34.5f);
                        if (blockable_damage > max_blockable_damage)
                        {
                            blockable_damage = max_blockable_damage;
                        }
 
                        dmg += blockable_damage;
 
                    }
                }
            } break;
 
            //SPELL_HASH_BLOODTHIRST
            case 23880:
            case 23881:
            {
                if (p_caster != nullptr)
                {
                    dmg = static_cast<uint32_t>(std::round(p_caster->getCalculatedAttackPower() * 0.5));
                    break;
                }
            }
            case 23885:
            case 23892:
            case 23893:
            case 23894:
            case 25251:
            case 30335:
            case 30474:
            case 30475:
            case 30476:
            case 31996:
            case 31997:
            case 31998:
            case 33964:
            case 35123:
            case 35125:
            case 35947:
            case 35948:
            case 35949:
            case 39070:
            case 39071:
            case 39072:
            case 40423:
            case 55968:
            case 55969:
            case 55970:
            case 57790:
            case 57791:
            case 57792:
            case 60017:
            case 71938:
            {
                dmg = u_caster->getCalculatedAttackPower() * (getSpellInfo()->calculateEffectValue(0)) / 100;
            } break;
 
            //SPELL_HASH_CONCUSSION_BLOW
            case 12809:
            case 22427:
            case 32588:
            case 52719:
            case 54132:
            {
                //3.2.2
                //[Concussion Blow]: The damage done by this ability has been reduced by 50%,
                //but its threat generation will remain approximately the same.
                dmg = u_caster->getCalculatedAttackPower() * (getSpellInfo()->calculateEffectValue(2)) / 100;
            } break;
 
            // SPELL_HASH_INTERCEPT
            case 20252:
            {
                if (p_caster != nullptr)
                {
                    dmg = static_cast<uint32_t>(std::round(p_caster->getCalculatedAttackPower() * 0.12));
                    break;
                }
            }
            case 20253:
            case 20614:
            case 20615:
            case 20616:
            case 20617:
            case 25272:
            case 25273:
            case 25274:
            case 25275:
            case 27577:
            case 27826:
            case 30151:
            case 30153:
            case 30154:
            case 30194:
            case 30195:
            case 30197:
            case 30198:
            case 30199:
            case 30200:
            case 47995:
            case 47996:
            case 50823:
            case 58743:
            case 58747:
            case 58769:
            case 61490:
            case 61491:
            case 67540:
            case 67573:
            {
                if (u_caster)
                    dmg = Util::float2int32(u_caster->getCalculatedAttackPower() * 0.12f);
            } break;
 
            case 5308:
            case 20658:
            case 20660:
            case 20661:
            case 20662:
            case 25234:
            case 25236:
            case 47470:
            case 47471:
            {
                if (p_caster != nullptr)
                    dmg = p_caster->getCalculatedAttackPower() * ((m_spellInfo->calculateEffectValue(0)) / 100);
            }break;
 
            //SPELL_HASH_SHIELD_SLAM
            /* Zyres 10/06/2017: Already defined!
            case 23922:
            case 23923:
            case 23924:
            case 23925:
            case 25258:
            case 30356:
            case 47487:
            case 47488:
            {
                if (p_caster != NULL)
                {
#if VERSION_STRING != Classic
                    Item* it = static_cast<Item*>(p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_OFFHAND));
                    if (it && it->getItemProperties() && it->getItemProperties()->InventoryType == INVTYPE_SHIELD)
                        dmg = p_caster->getUInt32Value(PLAYER_SHIELD_BLOCK);
#endif
                }
            }break;*/
            case 34428:
            {
                if (p_caster != nullptr)
                {
                    p_caster->removeAuraStateAndAuras(AURASTATE_FLAG_SWIFTMEND);
                    dmg = (p_caster->getCalculatedAttackPower()*(m_spellInfo->getEffectBasePoints(effectIndex) + 1)) / 100;
                }
            }break;
            case 6572:
            case 6574:
            case 7379:
            case 11600:
            case 11601:
            case 25288:
            case 25269:
            case 30357:
            case 57823:
            {
                if (p_caster != nullptr)
                    dmg = static_cast<uint32_t>(std::round(p_caster->getCalculatedAttackPower() * 0.207));
            }break;
 
            case 64382:
                if (p_caster != nullptr)
                    dmg = static_cast<uint32_t>(std::round(p_caster->getCalculatedAttackPower() * 0.5));
                break;
 
            case 29707:
            case 30324:
            case 47449:
            case 47450:
            {
                /* Possibly broken (infinity loop) -- ask Zyres
                if (p_caster != nullptr)
                {
                    if (m_unitTarget->isDazed())
                        for (uint32_t i = UNIT_FIELD_AURASTATE; i < AURASTATE_FLAG_SWIFTMEND; i)
                        {
                            switch (m_spellInfo->getId())
                            { // This info isn't in the dbc files.....
                                case 29707:
                                    dmg = static_cast<uint32_t>(std::round(81.9));
                                    break;
                                case 30324:
                                    dmg = static_cast<uint32_t>(std::round(110.95));
                                    break;
                                case 47449:
                                    dmg = static_cast<uint32_t>(std::round(151.2));
                                    break;
                                case 47450:
                                    dmg = static_cast<uint32_t>(std::round(173.25));
                                    break;
                            }
                        }
                }
                */
            }break;
            case 845:
            case 7369:
            case 11608:
            case 11609:
            case 20569:
            case 25231:
            case 47519:
            case 47520:
            {
                if (p_caster != nullptr)
                {
                    auto item = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                    if (item != nullptr)
                    {
                        if (p_caster->hasAurasWithId(12329))
                            dmg = static_cast<uint32_t>(std::round((((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) + m_spellInfo->getEffectBasePoints(effectIndex)) * 0.4));
                        else if (p_caster->hasAurasWithId(12950))
                            dmg = static_cast<uint32_t>(std::round((((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) + m_spellInfo->getEffectBasePoints(effectIndex)) * 0.8));
                        else if (p_caster->hasAurasWithId(20496))
                            dmg = static_cast<uint32_t>(std::round((((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) + m_spellInfo->getEffectBasePoints(effectIndex)) * 1.2));
                        else
                            dmg = static_cast<uint32_t>(std::round(((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) + m_spellInfo->getEffectBasePoints(effectIndex)));
                    }
                }
            }break;
            // Slam
            case 1464:
            case 8820:
            case 11604:
            case 11605:
            case 25241:
            case 25242:
            case 47474:
            case 47475:
            {
                if (p_caster != nullptr)
                {
                    auto item = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
                    if (item != nullptr)
                        dmg = static_cast<uint32_t>(std::round(((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) + m_spellInfo->getEffectBasePoints(effectIndex)));
                }
            }break;
 
            case 31898:
            case 31804:
            case 20187:
            case 53733:
            case 57774:
            case 20268:
            case 53726:
            {
                if (p_caster != nullptr)
                {
                    if (p_caster->hasAurasWithId(34258))
                        p_caster->castSpell(p_caster, 34260, true);
                    if ((p_caster->hasAurasWithId(53696) || p_caster->hasAurasWithId(53695)))
                        p_caster->castSpell(p_caster, 68055, true);
                    if (p_caster->hasAurasWithId(37186))
                        dmg = 33;
                }
            }break;
 
            case 25742:
            {
                if (p_caster != nullptr)
                    dmg = static_cast<uint32_t>(std::round(p_caster->getBaseAttackTime(MELEE) / 1000 * ((0.022 * (p_caster->getCalculatedAttackPower()) + (0.044 * (p_caster->GetDamageDoneMod(1))))) + m_spellInfo->getEffectBasePoints(effectIndex)));
            }break;
            case 19434:
            case 20900:
            case 20901:
            case 20902:
            case 20903:
            case 20904:
            case 27065:
            case 49049:
            case 49050:
            {
                if (p_caster != nullptr)
                {
                    auto item = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
                    if (item != nullptr)
                        dmg = static_cast<uint32_t>(std::round(((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) + m_spellInfo->getEffectBasePoints(effectIndex)));
 
                }
            }break;
            case 53209:
            {
                if (p_caster != nullptr)
                {
                    auto item = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
                    if (item != nullptr)
                        dmg = static_cast<uint32_t>(std::round(((item->getItemProperties()->Damage[0].Min + item->getItemProperties()->Damage[0].Max) * 0.2f) * 1.25));
                }
            }break;
            case 56641:
            case 34120:
            case 49051:
            case 49052:
            {
#if VERSION_STRING < Cata
                if (p_caster != nullptr)
                {
                    Item* pItem = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
                    ItemProperties const* pItemProto = sMySQLStore.getItemProperties(p_caster->getAmmoId());
                    uint32_t stundmg;
                    float bowdmg;
                    float ammodmg;
                    if (m_unitTarget->isDazed())
                        stundmg = p_caster->getCalculatedRangedAttackPower() / 10 + m_spellInfo->getEffectBasePoints(effectIndex) + m_spellInfo->getEffectBasePoints(effectIndex + 1);
                    else
                        stundmg = p_caster->getCalculatedRangedAttackPower() / 10 + m_spellInfo->getEffectBasePoints(effectIndex);
                    if (pItem)
                        bowdmg = (pItem->getItemProperties()->Damage[0].Min + pItem->getItemProperties()->Damage[0].Max) * 0.2f;
                    else
                        bowdmg = 0;
                    if (pItemProto)
                        ammodmg = (pItemProto->Damage[0].Min + pItemProto->Damage[0].Max) * 0.2f;
                    else
                        ammodmg = 0;
 
                    dmg = Util::float2int32(ammodmg + bowdmg) + stundmg;
                }
#endif
            }break;
            case 64422: // Sonic Screech, Auriaya encounter
            case 64688:
            {
                if (u_caster != nullptr)
                {
                    int splitCount = 0;
                    for (const auto& itr : u_caster->getInRangeOppositeFactionSet())
                    {
                        if (itr && itr->isInFront(u_caster))
                            splitCount++;
                    }
 
                    if (splitCount > 1)
                        dmg /= splitCount;
                }
            }
            break;
            default:
                break;
        };
    }
 
    if (p_caster && !static_damage)   //this is wrong but with current spell coef system it has to be here...
    {
        switch (p_caster->getClass())
        {
            case WARRIOR:
            case ROGUE:
            case HUNTER:
#if VERSION_STRING > TBC
            case DEATHKNIGHT:
#endif
                static_damage = true; //No spells from these classes benefit from spell damage. Prevents Arc hunters, frost DKs, etc.
                break;
            default:
                break;
        }
    }
 
 
    // check for no more damage left (chains)
    if (!dmg)
        dmg = getSpellInfo()->getEffectBasePoints(effectIndex);
 
    if (!dmg)
        return;
 
    if (getSpellInfo()->getSpeed() > 0 && m_triggeredSpell == false)
    {
        m_targetDamageInfo = m_caster->doSpellDamage(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(dmg), effectIndex, pSpellId != 0, false, false, isForcedCrit, this);
        isTargetDamageInfoSet = true;
    }
    else
    {
        if (GetType() == SPELL_DMG_TYPE_MAGIC)
        {
            m_targetDamageInfo = m_caster->doSpellDamage(m_unitTarget, getSpellInfo()->getId(), static_cast<float_t>(dmg), effectIndex, m_triggeredSpell, false, false, isForcedCrit, this);
            isTargetDamageInfoSet = true;
        }
        else
        {
            if (u_caster != nullptr)
            {
                WeaponDamageType _type;
                if (GetType() == SPELL_DMG_TYPE_RANGED)
                    _type = RANGED;
                else
                {
                    if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_REQUIRES_OFFHAND_WEAPON)
                        _type = OFFHAND;
                    else
                        _type = MELEE;
                }
 
                m_targetDamageInfo = u_caster->strike(m_unitTarget, _type, getSpellInfo(), 0, 0, dmg, m_triggeredSpell, true, (force_crit || isForcedCrit), this);
                isTargetDamageInfoSet = true;
            }
        }
    }
}

Here is the call graph for this function:

◆ spellEffectScriptEffect()

void Spell::spellEffectScriptEffect ( uint8_t effectIndex )

Definition at line 642 of file SpellEffects.Legacy.cpp.

{
    // Check that the scripted effect is handled properly in spell script
    // In case it's not, send error log
    const auto scriptResult = sScriptMgr.callScriptedSpellOnDummyOrScriptedEffect(this, effectIndex);
    if (scriptResult == SpellScriptCheckDummy::DUMMY_OK)
        return;
 
    // Legacy scripts
    if (sScriptMgr.CallScriptedDummySpell(m_spellInfo->getId(), effectIndex, this))
        return;
 
    // Legacy scripts
    if (sScriptMgr.HandleScriptedSpellEffect(m_spellInfo->getId(), effectIndex, this))
        return;
 
    sLogger.failure("Spell::spellEffectScriptEffect : Spell {} ({}) has a scripted effect index (%hhu), but no handler for it.", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
}

Here is the call graph for this function:

◆ spellEffectSelfResurrect()

void Spell::spellEffectSelfResurrect ( uint8_t effectIndex )

◆ SpellEffectSelfResurrect()

void Spell::SpellEffectSelfResurrect ( uint8_t effectIndex )

Definition at line 4904 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster || !m_unitTarget || m_playerTarget->isAlive()) return;
 
    uint32_t mana;
    uint32_t health;
    uint32_t class_ = m_unitTarget->getClass();
 
    switch (getSpellInfo()->getId())
    {
        case 3026:
        case 20758:
        case 20759:
        case 20760:
        case 20761:
        case 27240:
        case 47882:
        {
            health = getSpellInfo()->getEffectMiscValue(effectIndex);
            mana = -damage;
        }
        break;
        case 21169: //Reincarnation. Resurrect with 20% health and mana
        {
            int32_t amt = damage;
            health = uint32_t((m_unitTarget->getMaxHealth() * amt) / 100);
            mana = uint32_t((m_unitTarget->getMaxPower(POWER_TYPE_MANA) * amt) / 100);
        }
        break;
        default:
        {
            if (damage < 0) return;
            health = uint32_t(m_unitTarget->getMaxHealth() * damage / 100);
            mana = uint32_t(m_unitTarget->getMaxPower(POWER_TYPE_MANA) * damage / 100);
        }
        break;
    }
 
    if (class_ == WARRIOR || class_ == ROGUE)
        mana = 0;
 
    m_playerTarget->setResurrectHealth(health);
    m_playerTarget->setResurrectMana(mana);
 
    m_playerTarget->resurrect();
    m_playerTarget->setMoveRoot(false);
 
    m_playerTarget->setSelfResurrectSpell(0);
 
    if (getSpellInfo()->getId() == 21169)
        p_caster->addSpellCooldown(getSpellInfo(), i_caster, this);
}

Here is the call graph for this function:

◆ spellEffectSendEvent()

void Spell::spellEffectSendEvent ( uint8_t effectIndex )

◆ SpellEffectSendEvent()

void Spell::SpellEffectSendEvent ( uint8_t effectIndex )

Definition at line 4337 of file SpellEffects.Legacy.cpp.

{
    //This is mostly used to trigger events on quests or some places
 
    if (sScriptMgr.CallScriptedDummySpell(m_spellInfo->getId(), effectIndex, this))
        return;
 
    if (sScriptMgr.HandleScriptedSpellEffect(m_spellInfo->getId(), effectIndex, this))
        return;
 
    sLogger.debugFlag(AscEmu::Logging::LF_SPELL_EFF, "Spell ID: {} ({}) has a scripted effect index ({}) but no handler for it.", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
 
}

Here is the call graph for this function:

◆ spellEffectSetMirrorName()

void Spell::spellEffectSetMirrorName ( uint8_t effectIndex )

◆ spellEffectSkill()

void Spell::spellEffectSkill ( uint8_t effectIndex )

Definition at line 661 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
        return;
 
    const auto skillLine = static_cast<uint16_t>(getSpellInfo()->getEffectMiscValue(effectIndex));
    const auto amount = static_cast<uint16_t>(damage * 75);
 
    if (m_playerTarget->hasSkillLine(skillLine))
    {
        if (amount > m_playerTarget->getSkillLineMax(skillLine))
            m_playerTarget->modifySkillMaximum(skillLine, amount);
    }
    else
    {
        m_playerTarget->addSkillLine(skillLine, 1, amount);
    }
}

Here is the call graph for this function:

◆ spellEffectSkillStep()

void Spell::spellEffectSkillStep ( uint8_t effectIndex )

Definition at line 593 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
        return;
 
    auto skillId = static_cast<uint16_t>(getSpellInfo()->getEffectMiscValue(effectIndex));
#if VERSION_STRING <= WotLK
    // TODO: check if this is needed anymore
    // Legacy comment: somehow for lockpicking misc is different than the skill :s
    if (skillId == 242)
        skillId = SKILL_LOCKPICKING;
#endif
 
    const auto skillLine = sSkillLineStore.lookupEntry(skillId);
    if (skillLine == nullptr)
        return;
 
    // Set new skill maximum value for professions only
    // Other types will be handled on skill apply
    uint16_t max = 0;
    if (skillLine->type == SKILL_TYPE_PROFESSION || skillLine->type == SKILL_TYPE_SECONDARY)
        max = static_cast<uint16_t>(damage * 75);
 
    if (m_playerTarget->hasSkillLine(skillId))
        m_playerTarget->modifySkillMaximum(skillId, max);
    else
        m_playerTarget->addSkillLine(skillId, 1, max);
}

Here is the call graph for this function:

◆ spellEffectSkinning()

void Spell::spellEffectSkinning ( uint8_t effectIndex )

◆ SpellEffectSkinning()

void Spell::SpellEffectSkinning ( uint8_t effectIndex )

Definition at line 4957 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isCreature())
        return;
 
    Creature* cr = static_cast<Creature*>(m_unitTarget);
    auto skill = cr->GetRequiredLootSkill();
    auto sk = static_cast<Player*>(m_caster)->getSkillLineCurrent(skill);
    uint32_t lvl = cr->getLevel();
 
    if ((sk >= lvl * 5) || ((sk + 100U) >= lvl * 10))
    {
        //Fill loot for Skinning
        sLootMgr.fillSkinningLoot(p_caster, &cr->loot, m_unitTarget->getEntry(), 0);
        static_cast<Player*>(m_caster)->sendLoot(m_unitTarget->getGuid(), LOOT_SKINNING, m_unitTarget->GetMapId());
 
        //Not skinable again
        cr->removeUnitFlags(UNIT_FLAG_SKINNABLE);
        cr->Skinned = true;
 
        if (cr->GetCreatureProperties()->Rank > 0)
            DetermineSkillUp(skill, sk < lvl * 5 ? sk / 5 : lvl, 2);
        else
            DetermineSkillUp(skill, sk < lvl * 5 ? sk / 5 : lvl, 1);
    }
    else
    {
        sendCastResult(SPELL_FAILED_TARGET_UNSKINNABLE);
    }
}

Here is the call graph for this function:

◆ spellEffectSkinPlayerCorpse()

void Spell::spellEffectSkinPlayerCorpse ( uint8_t effectIndex )

◆ SpellEffectSkinPlayerCorpse()

void Spell::SpellEffectSkinPlayerCorpse ( uint8_t effectIndex )

Definition at line 5439 of file SpellEffects.Legacy.cpp.

{
    Corpse* corpse = nullptr;
    if (!m_playerTarget)
    {
        // means we're "skinning" a corpse
        corpse = sObjectMgr.getCorpseByGuid((uint32_t)m_targets.getUnitTargetGuid());  // hacky
    }
    else if (m_playerTarget->getDeathState() == CORPSE)   // repopped while we were casting
    {
        corpse = sObjectMgr.getCorpseByGuid(m_playerTarget->getGuidLow());
    }
 
    if (p_caster == nullptr)
        return;
 
    if (m_playerTarget && !corpse)
    {
        if (!m_playerTarget->getBattleground() || !m_playerTarget->isDead())
            return;
 
        // Set all the lootable stuff on the player. If he repops before we've looted, we'll set the flags
        // on corpse then :p
 
        m_playerTarget->setLootableOnCorpse(false);
        m_playerTarget->removeUnitFlags(UNIT_FLAG_SKINNABLE);
        m_playerTarget->addDynamicFlags(U_DYN_FLAG_LOOTABLE);
 
        // Send the loot.
        p_caster->sendLoot(m_playerTarget->getGuid(), LOOT_SKINNING, m_playerTarget->GetMapId());
 
        // Send a message to the died player, telling him he has to resurrect at the graveyard.
        // Send an empty corpse location too, :P
 
        m_playerTarget->sendPacket(MsgCorspeQuery(0).serialise().get());
 
        // don't allow him to spawn a corpse
        m_playerTarget->setAllowedToCreateCorpse(false);
 
        // and.. force him to the graveyard and repop him.
        m_playerTarget->repopRequest();
 
    }
    else if (corpse)
    {
        // find the corpses' owner
        WoWGuid wowGuid;
        wowGuid.Init(corpse->getOwnerGuid());
 
        Player* owner = sObjectMgr.getPlayer(wowGuid.getGuidLowPart());
        if (owner)
        {
            if (!owner->getBattleground())
                return;
 
            owner->sendPacket(MsgCorspeQuery(0).serialise().get());
        }
 
        if (corpse->getDynamicFlags() != 1)
            corpse->setDynamicFlags(1); // sets it so you can loot the plyr
 
        // remove skinnable flag
        corpse->setFlags(CORPSE_FLAG_BONE | CORPSE_FLAG_UNK1);
 
        // remove owner association
        corpse->setOwnerNotifyMap(0);
        corpse->setCorpseState(CORPSE_STATE_BONES);
 
        // send loot
        p_caster->sendLoot(corpse->getGuid(), LOOT_SKINNING, corpse->GetMapId());
 
        corpse->deleteFromDB();
        sObjectMgr.addCorpseDespawnTime(corpse);
    }
}

Here is the call graph for this function:

◆ spellEffectSpawn()

void Spell::spellEffectSpawn ( uint8_t effectIndex )

◆ SpellEffectSpawn()

void Spell::SpellEffectSpawn ( uint8_t effectIndex )

Definition at line 3911 of file SpellEffects.Legacy.cpp.

{
    // this effect is mostly for custom teleporting
    switch (getSpellInfo()->getId())
    {
        case 10418: // Arugal spawn-in spell , teleports it to 3 locations randomly sneaking players (bastard ;P)
        {
            //only Creature can cast this spell
            if (u_caster == nullptr || p_caster != nullptr)
                return;
 
            //static float coord[3][3] = { { -108.9034f, 2129.5678f, 144.9210f }, { -108.9034f, 2155.5678f, 155.678f }, { -77.9034f, 2155.5678f, 155.678f } };
 
            // uint8_t j = RandomUInt(3);
            //u_caster->getAIInterface()->SendMoveToPacket(coord[j][0],coord[j][1],coord[j][2],0.0f,0,u_caster->getAIInterface()->getMoveFlags());
        }
    }
}

Here is the call graph for this function:

◆ spellEffectSpellDefense()

void Spell::spellEffectSpellDefense ( uint8_t effectIndex )

◆ SpellEffectSpellDefense()

void Spell::SpellEffectSpellDefense ( uint8_t effectIndex )

Definition at line 3787 of file SpellEffects.Legacy.cpp.

{
    //used to enable this ability. We use it all the time ...
}

◆ spellEffectSpellSteal()

void Spell::spellEffectSpellSteal ( uint8_t effectIndex )

◆ SpellEffectSpellSteal()

void Spell::SpellEffectSpellSteal ( uint8_t effectIndex )

Definition at line 5854 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || u_caster == nullptr || !m_unitTarget->isAlive())
        return;
 
    if (m_playerTarget != nullptr && p_caster != nullptr && p_caster != m_playerTarget)
    {
        if (m_playerTarget->isPvpFlagSet())
            p_caster->togglePvP();
    }
 
    uint16_t start, end;
    if (u_caster->isValidTarget(m_unitTarget))
    {
        start = AuraSlots::POSITIVE_SLOT_START;
        end = AuraSlots::POSITIVE_SLOT_END;
    }
    else
        return;
 
    std::list< uint32_t > stealedSpells;
 
    for (auto x = start; x < end; x++)
    {
        if (auto* const aur = m_unitTarget->getAuraWithAuraSlot(x))
        {
            SpellInfo const* aursp = aur->getSpellInfo();
 
            if (aursp->getId() != 15007 && !aur->IsPassive()
                //              && aur->IsPositive()    // Zack : We are only checking positive auras. There is no meaning to check again
               ) //Nothing can dispel resurrection sickness
            {
                if (aursp->getDispelType() == DISPEL_MAGIC)
                {
                    stealedSpells.push_back(aursp->getId());
 
                    uint32_t aurdur = (aur->getTimeLeft() > 120000 ? 120000 : aur->getTimeLeft());
                    auto aura = sSpellMgr.newAura(aursp, aurdur, u_caster, u_caster);
                    m_unitTarget->removeAllAurasByIdReturnCount(aursp->getId());
                    for (uint8_t j = 0; j < 3; j++)
                    {
                        if (aura->getSpellInfo()->getEffect(j))
                        {
                            aura->addAuraEffect(static_cast<AuraEffect>(aura->getSpellInfo()->getEffectApplyAuraName(j)), aura->getSpellInfo()->getEffectBasePoints(j) + 1, aura->getSpellInfo()->getEffectMiscValue(j), aur->getAuraEffect(j)->getEffectPercentModifier(), true, j);
                        }
                    }
                    u_caster->addAura(std::move(aura));
                    break;
                }
            }
        }
    }
 
    if (!stealedSpells.empty())
    {
        m_caster->sendMessageToSet(SmsgSpellStealLog(m_caster->getGuid(), m_unitTarget->getGuid(), getSpellInfo()->getId(), stealedSpells).serialise().get(), true);
    }
}

Here is the call graph for this function:

◆ spellEffectStartTaxi()

void Spell::spellEffectStartTaxi ( uint8_t effectIndex )

◆ SpellEffectStartTaxi()

void Spell::SpellEffectStartTaxi ( uint8_t effectIndex )

Definition at line 5799 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget || !m_playerTarget->isAlive() || !u_caster)
        return;
 
    if (!m_unitTarget || !m_unitTarget->isPlayer())
        return;
 
    m_unitTarget->ToPlayer()->activateTaxiPathTo(m_spellInfo->getEffectMiscValue(effectIndex), m_spellInfo->getId());
}

Here is the call graph for this function:

◆ spellEffectStuck()

void Spell::spellEffectStuck ( uint8_t effectIndex )

◆ SpellEffectStuck()

void Spell::SpellEffectStuck ( uint8_t effectIndex )

Definition at line 4771 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget || m_playerTarget != p_caster)
        return;
 
    sEventMgr.AddEvent(m_playerTarget, &Player::eventTeleport, m_playerTarget->getBindMapId(), LocationVector(m_playerTarget->getBindPosition().x, m_playerTarget->getBindPosition().y,
                       m_playerTarget->getBindPosition().z, m_playerTarget->getBindPosition().o), uint32_t(0), EVENT_PLAYER_TELEPORT, 50, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
    /*
    playerTarget->SafeTeleport(playerTarget->getBindMapId(), 0, playerTarget->GetBindPositionX(), playerTarget->GetBindPositionY(), playerTarget->GetBindPositionZ(), 3.14f);*/
}

Here is the call graph for this function:

◆ spellEffectSummon()

void Spell::spellEffectSummon ( uint8_t effectIndex )

◆ SpellEffectSummon()

void Spell::SpellEffectSummon ( uint8_t effectIndex )

virtual

Definition at line 2825 of file SpellEffects.Legacy.cpp.

{
    uint32_t summonpropid = m_spellInfo->getEffectMiscValueB(effectIndex);
 
    auto summon_properties = sSummonPropertiesStore.lookupEntry(summonpropid);
    if (summon_properties == nullptr)
    {
        sLogger.failure("No SummonPropertiesEntry for Spell {} ({})", m_spellInfo->getId(), m_spellInfo->getName());
        return;
    }
 
    uint32_t entry = m_spellInfo->getEffectMiscValue(effectIndex);
 
    CreatureProperties const* cp = sMySQLStore.getCreatureProperties(entry);
 
    if (cp == nullptr)
    {
        sLogger.failure("Spell {} ({}) tried to summon creature {} without database data", m_spellInfo->getId(), m_spellInfo->getName(), entry);
        return;
    }
 
    LocationVector v(0.0f, 0.0f, 0.0f, 0.0f);
 
    if ((m_targets.hasDestination()) != 0)
        v = m_targets.getDestination();
    else
        v = m_caster->GetPosition();
 
    // Ugly hack to make sure we always summon at least 1
    if (damage == 0)
        damage = 1;
 
    // Client adds these spells to the companion window, it's weird but then it happens anyways
    if (summon_properties->Slot == 5)
    {
        SpellEffectSummonCompanion(effectIndex, summon_properties, cp, v);
        return;
    }
 
    switch (summon_properties->ControlType)
    {
        case SUMMON_CONTROL_TYPE_GUARDIAN:
            if (summon_properties->ID == 121)
            {
                spellEffectSummonTotem(effectIndex, summon_properties, cp, v);
                return;
            }
            break;
 
        case SUMMON_CONTROL_TYPE_PET:
            SpellEffectSummonTemporaryPet(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_CONTROL_TYPE_POSSESSED:
            SpellEffectSummonPossessed(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_CONTROL_TYPE_VEHICLE:
            SpellEffectSummonVehicle(effectIndex, summon_properties, cp, v);
            return;
        case SUMMON_CATEGORY_UNK:
            if (summon_properties->Flags & 512)
            {
                SpellEffectSummonGuardian(effectIndex, summon_properties, cp, v);
                return;
            }
    }
 
    switch (summon_properties->Type)
    {
        case SUMMON_TYPE_NONE:
        case SUMMON_TYPE_CONSTRUCT:
        case SUMMON_TYPE_OPPONENT:
 
            if (summon_properties->ControlType == SUMMON_CONTROL_TYPE_GUARDIAN)
                SpellEffectSummonGuardian(effectIndex, summon_properties, cp, v);
            else
                SpellEffectSummonWild(effectIndex);
 
            return;
 
        case SUMMON_TYPE_PET:
            SpellEffectSummonTemporaryPet(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_TYPE_GUARDIAN:
        case SUMMON_TYPE_MINION:
        case SUMMON_TYPE_RUNEBLADE:
            SpellEffectSummonGuardian(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_TYPE_TOTEM:
            spellEffectSummonTotem(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_TYPE_COMPANION:
            // These are used as guardians in some quests
            if (summon_properties->Slot == 6)
                SpellEffectSummonGuardian(effectIndex, summon_properties, cp, v);
            else
                SpellEffectSummonCompanion(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_TYPE_VEHICLE:
        case SUMMON_TYPE_MOUNT:
            SpellEffectSummonVehicle(effectIndex, summon_properties, cp, v);
            return;
 
        case SUMMON_TYPE_LIGHTWELL:
            SpellEffectSummonGuardian(effectIndex, summon_properties, cp, v);
            return;
    }
 
    sLogger.failure("Unknown summon type in summon property {} in spell {} {}", summonpropid, m_spellInfo->getId(), m_spellInfo->getName());
}

Here is the call graph for this function:

◆ SpellEffectSummonCompanion()

void Spell::SpellEffectSummonCompanion	(	uint32_t	i,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

Definition at line 3104 of file SpellEffects.Legacy.cpp.

{
    if (u_caster == nullptr)
        return;
 
#if VERSION_STRING > TBC
    if (u_caster->getCritterGuid() != 0)
    {
        auto critter = u_caster->getWorldMap()->getUnit(u_caster->getCritterGuid());
        if (critter == nullptr)
            return;
 
        auto creature = static_cast< Creature* >(critter);
 
        uint32_t currententry = creature->GetCreatureProperties()->Id;
 
        creature->RemoveFromWorld(false, true);
        u_caster->setCritterGuid(0);
 
        // Before WOTLK when you casted the companion summon spell the second time it removed the companion
        // Customized servers or old databases could still use this method
        if (properties_->Id == currententry)
            return;
    }
 
    auto summon = u_caster->getWorldMap()->summonCreature(properties_->Id, v, spe, static_cast<uint32_t>(getDuration()), u_caster, m_spellInfo->getId());
    if (summon == nullptr)
        return;
 
    u_caster->setCritterGuid(summon->getGuid());
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectSummonCompanion()

void Spell::spellEffectSummonCompanion	(	uint8_t	effectIndex,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

◆ spellEffectSummonDeadPet()

void Spell::spellEffectSummonDeadPet ( uint8_t effectIndex )

◆ SpellEffectSummonDeadPet()

void Spell::SpellEffectSummonDeadPet ( uint8_t effectIndex )

Definition at line 5259 of file SpellEffects.Legacy.cpp.

{
    //this is pet resurrect
    if (!p_caster)
        return;
    Pet* pPet = p_caster->getPet();
    if (pPet)
    {
        // Pet should teleport to owner's position
        HandleTeleport(p_caster->GetPosition(), p_caster->GetMapId(), pPet);
        //\note remove all dynamic flags
        pPet->setDynamicFlags(0);
        pPet->setHealth(pPet->getMaxHealth() * damage / 100);
        pPet->setDeathState(ALIVE);
        pPet->getAIInterface()->handleEvent(EVENT_FOLLOWOWNER, pPet, 0);
        pPet->sendSpellsToController(p_caster, pPet->getTimeLeft());
 
        // Restore unit and pvp flags that were resetted on death
        if (p_caster->isPvpFlagSet())
            pPet->setPvpFlag();
        else
            pPet->removePvpFlag();
 
        if (p_caster->isFfaPvpFlagSet())
            pPet->setFfaPvpFlag();
        else
            pPet->removeFfaPvpFlag();
 
        if (p_caster->isSanctuaryFlagSet())
            pPet->setSanctuaryFlag();
        else
            pPet->removeSanctuaryFlag();
 
        if (p_caster->hasUnitFlags(UNIT_FLAG_PVP_ATTACKABLE))
            pPet->addUnitFlags(UNIT_FLAG_PVP_ATTACKABLE);
 
#if VERSION_STRING == TBC
        if (p_caster->hasUnitFlags(UNIT_FLAG_PVP_ATTACKABLE))
            pPet->setPositiveAuraLimit(POS_AURA_LIMIT_PVP_ATTACKABLE);
        else
            pPet->setPositiveAuraLimit(POS_AURA_LIMIT_CREATURE);
#endif
    }
    else
    {
        // This was set in canCast so it should exist at this point
        if (add_damage == 0)
            return;
 
        if (!p_caster->isPetRequiringTemporaryUnsummon())
            p_caster->spawnPet(static_cast<uint8_t>(add_damage));
 
        pPet = p_caster->getPet();
        if (pPet == nullptr)//no pets to Revive
            return;
 
        pPet->setHealth(pPet->getMaxHealth() * damage / 100);
    }
}

Here is the call graph for this function:

◆ SpellEffectSummonGuardian()

void Spell::SpellEffectSummonGuardian	(	uint32_t	i,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

Definition at line 3013 of file SpellEffects.Legacy.cpp.

{
    if (u_caster == nullptr)
        return;
 
    float angle_for_each_spawn = -M_PI_FLOAT * 2 / damage;
 
    for (int j = 0; j < damage; j++)
    {
        float followangle = angle_for_each_spawn * j;
 
        float x = 3 * (cosf(followangle + u_caster->GetOrientation()));
        float y = 3 * (sinf(followangle + u_caster->GetOrientation()));
 
        v.x += x;
        v.y += y;
 
        Summon* s = u_caster->getWorldMap()->summonCreature(properties_->Id, v, spe, static_cast<uint32_t>(getDuration()), u_caster, getSpellInfo()->getId());
        if (s == nullptr)
            return;
 
        // Lightwell
        if (spe->Type == SUMMON_TYPE_LIGHTWELL)
        {
            s->setMoveRoot(true);
            s->addNpcFlags(UNIT_NPC_FLAG_SPELLCLICK);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectSummonGuardian()

void Spell::spellEffectSummonGuardian	(	uint8_t	effectIndex,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

◆ spellEffectSummonObject()

void Spell::spellEffectSummonObject ( uint8_t effectIndex )

◆ SpellEffectSummonObject()

void Spell::SpellEffectSummonObject ( uint8_t effectIndex )

Definition at line 3930 of file SpellEffects.Legacy.cpp.

{
    if (!u_caster)
        return;
 
    uint32_t entry = getSpellInfo()->getEffectMiscValue(effectIndex);
 
    GameObjectProperties const* info = sMySQLStore.getGameObjectProperties(entry);
    if (info == nullptr)
    {
        sLogger.failure("Spell {} ( {} ) Effect Index {} tried to summon a GameObject with ID {}. GameObject is not in the database.", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex, entry);
        return;
    }
 
    WorldMap* map = m_caster->getWorldMap();
    float px = u_caster->GetPositionX();
    float py = u_caster->GetPositionY();
    float pz = u_caster->GetPositionZ();
 
    int32_t duration = getDuration();
    GameObject* go = nullptr;
 
    if (info->type == GAMEOBJECT_TYPE_FISHINGNODE)
    {
        if (p_caster == nullptr)
            return;
 
        float minDist = m_spellInfo->getMinRange(true);
        float maxDist = m_spellInfo->getMaxRange(true);
        float posx = 0, posy = 0, posz = 0;
        float dist = Util::getRandomFloat(minDist, maxDist);
 
        float angle = Util::getRandomFloat(0.0f, 1.0f) * static_cast<float>(M_PI * 35.0f / 180.0f) - static_cast<float>(M_PI * 17.5f / 180.0f);
        m_caster->getClosePoint(posx, posy, posz, 0.388999998569489f, dist, angle);
 
        float liquidLevel = VMAP_INVALID_HEIGHT_VALUE;
 
        LiquidData liquidData;
        if (map->getLiquidStatus(m_caster->GetPhase(), LocationVector(posx, posy, posz), MAP_ALL_LIQUIDS, &liquidData, m_caster->getCollisionHeight()))
            liquidLevel = liquidData.level;
 
        go = u_caster->getWorldMap()->createGameObject(entry);
 
        LocationVector pos = { posx, posy, liquidLevel, u_caster->GetOrientation() };
        QuaternionData rot = QuaternionData::fromEulerAnglesZYX(u_caster->GetOrientation(), 0.f, 0.f);
 
        if (!go->create(entry, map, p_caster->GetPhase(), pos, rot, GO_STATE_CLOSED))
        {
            delete go;
            return;
        }
 
        go->setGoType(GAMEOBJECT_TYPE_FISHINGNODE);
        go->setCreatedByGuid(m_caster->getGuid());
        u_caster->addGameObject(go);
 
        go->PushToWorld(m_caster->getWorldMap());
 
        u_caster->setChannelObjectGuid(go->getGuid());
    }
    else
    {
        float posx = px;
        float posy = py;
        auto destination = m_targets.getDestination();
 
        if ((m_targets.hasDestination()) && destination.isSet())
        {
            posx = destination.x;
            posy = destination.y;
            pz = destination.z;
        }
 
        LocationVector pos = { posx, posy, pz, u_caster->GetOrientation() };
        QuaternionData rot = QuaternionData::fromEulerAnglesZYX(u_caster->GetOrientation(), 0.f, 0.f);
        go = u_caster->getWorldMap()->createGameObject(entry);
        if (!go->create(entry, map, u_caster->GetPhase(), pos, rot, GO_STATE_CLOSED))
        {
            delete go;
            return;
        }
 
        go->setCreatedByGuid(m_caster->getGuid());
        u_caster->addGameObject(go);
        go->PushToWorld(m_caster->getWorldMap());
    }
 
    switch (info->type)
    {
        case GAMEOBJECT_TYPE_FISHINGNODE:
        {
            go->setCreatedByGuid(m_caster->getGuid());
            u_caster->addGameObject(go);
            u_caster->setChannelObjectGuid(go->getGuid());
 
            int32_t lastSec = 0;
            switch (Util::getRandomUInt(0, 2))
            {
                case 0: lastSec = 3; break;
                case 1: lastSec = 7; break;
                case 2: lastSec = 13; break;
            }
 
            // Duration of the fishing bobber can't be higher than the Fishing channeling duration
            duration = std::min(duration, (duration - lastSec * IN_MILLISECONDS + 5 * IN_MILLISECONDS));
        } break;
        case GAMEOBJECT_TYPE_RITUAL:
        {
            if (u_caster->isPlayer())
            {
                go->setCreatedByGuid(m_caster->getGuid());
                u_caster->addGameObject(go);
 
                GameObject_Ritual* go_ritual = static_cast<GameObject_Ritual*>(go);
 
                go_ritual->GetRitual()->Setup(p_caster->getGuidLow(), 0, m_spellInfo->getId());
                go_ritual->GetRitual()->Setup(p_caster->getGuidLow(), static_cast<uint32_t>(p_caster->getTargetGuid()), m_spellInfo->getId());
            }
        } break;
        case GAMEOBJECT_TYPE_DUEL_ARBITER: // 52991
        {
            go->setCreatedByGuid(m_caster->getGuid());
            u_caster->addGameObject(go);
        } break;
        case GAMEOBJECT_TYPE_FISHINGHOLE:
        case GAMEOBJECT_TYPE_CHEST:
        default:
            break;
    }
 
    go->setRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
    go->setSpellId(m_spellInfo->getId());
 
    if (GameObject* linkedTrap = go->getLinkedTrap())
    {
        linkedTrap->setRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
        linkedTrap->setSpellId(m_spellInfo->getId());
    }
 
    if (p_caster != nullptr)
        p_caster->setSummonedObject(go);
}

Here is the call graph for this function:

◆ spellEffectSummonObjectSlot()

void Spell::spellEffectSummonObjectSlot ( uint8_t effectIndex )

◆ SpellEffectSummonObjectSlot()

void Spell::SpellEffectSummonObjectSlot ( uint8_t effectIndex )

Definition at line 5186 of file SpellEffects.Legacy.cpp.

{
    if (!u_caster || !u_caster->IsInWorld())
        return;
 
    GameObject* GoSummon = nullptr;
 
    uint32_t slot = getSpellInfo()->getEffect(effectIndex) - SPELL_EFFECT_SUMMON_OBJECT_SLOT1;
    GoSummon = u_caster->m_objectSlots[slot] ? u_caster->getWorldMap()->getGameObject(u_caster->m_objectSlots[slot]) : 0;
    u_caster->m_objectSlots[slot] = 0;
 
    if (uint32_t guid = u_caster->m_objectSlots[slot])
    {
        if (GameObject* obj = u_caster->getWorldMapGameObject(guid))
        {
            // Recast case - null spell id to make auras not be removed on object remove from world
            if (m_spellInfo->getId() == obj->getSpellId())
                obj->setSpellId(0);
            u_caster->removeGameObject(obj, true);
        }
        u_caster->m_objectSlots[slot] = 0;
    }
 
    // spawn a new one
    GoSummon = u_caster->getWorldMap()->createGameObject(getSpellInfo()->getEffectMiscValue(effectIndex));
 
    float dx = 0.0f;
    float dy = 0.0f;
    float dz = 0.0f;
 
    if (m_targets.hasDestination())
    {
        auto destination = m_targets.getDestination();
        dx = destination.x;
        dy = destination.y;
        dz = destination.z;
    }
    else
    {
        dx = m_caster->GetPositionX();
        dy = m_caster->GetPositionY();
        dz = m_caster->GetPositionZ();
    }
 
    QuaternionData rot = QuaternionData::fromEulerAnglesZYX(m_caster->GetOrientation(), 0.f, 0.f);
    if (!GoSummon->create(getSpellInfo()->getEffectMiscValue(effectIndex), m_caster->getWorldMap(), m_caster->GetPhase(), LocationVector(dx, dy, dz, m_caster->GetOrientation()), rot, GO_STATE_CLOSED))
    {
        delete GoSummon;
        return;
    }
 
    GoSummon->setLevel(u_caster->getLevel());
    GoSummon->setCreatedByGuid(m_caster->getGuid());
    GoSummon->Phase(PHASE_SET, u_caster->GetPhase());
 
    GoSummon->PushToWorld(m_caster->getWorldMap());
 
    int32_t duration = getDuration();
 
    GoSummon->setRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
    GoSummon->setSpellId(m_spellInfo->getId());
    u_caster->addGameObject(GoSummon);
    u_caster->m_objectSlots[slot] = GoSummon->GetUIdFromGUID();
}

Here is the call graph for this function:

◆ spellEffectSummonObjectWild()

void Spell::spellEffectSummonObjectWild ( uint8_t effectIndex )

◆ SpellEffectSummonObjectWild()

void Spell::SpellEffectSummonObjectWild ( uint8_t effectIndex )

Definition at line 4652 of file SpellEffects.Legacy.cpp.

{
    if (!u_caster)
        return;
 
    uint32_t gameobject_id = getSpellInfo()->getEffectMiscValue(effectIndex);
 
    float x, y, z;
    if (m_targets.hasDestination())
    {
        m_targets.getDestination().getPosition(x, y, z);
    }
    else
    {
        u_caster->getClosePoint(x, y, z, 0.388999998569489f);
    }
 
    WorldMap* map = u_caster->getWorldMap();
 
    QuaternionData rot = QuaternionData::fromEulerAnglesZYX(m_caster->GetOrientation(), 0.f, 0.f);
 
    // spawn a new one
    GameObject* GoSummon = u_caster->getWorldMap()->createGameObject(gameobject_id);
    if (!GoSummon->create(gameobject_id, map, m_caster->GetPhase(), LocationVector(x, y, z, m_caster->GetOrientation()), rot, GO_STATE_CLOSED))
    {
        delete GoSummon;
        return;
    }
 
    int32_t duration = getDuration();
 
    GoSummon->setRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
 
    GoSummon->PushToWorld(u_caster->getWorldMap());
    u_caster->addGameObject(GoSummon);
    GoSummon->setSpellId(m_spellInfo->getId());
 
    if (GameObject* linkedTrap = GoSummon->getLinkedTrap())
    {
        linkedTrap->setRespawnTime(duration > 0 ? duration / IN_MILLISECONDS : 0);
        linkedTrap->setSpellId(m_spellInfo->getId());
    }
}

Here is the call graph for this function:

◆ spellEffectSummonPet()

void Spell::spellEffectSummonPet ( uint8_t effectIndex )

◆ SpellEffectSummonPet()

void Spell::SpellEffectSummonPet ( uint8_t effectIndex )

Definition at line 4183 of file SpellEffects.Legacy.cpp.

{
    if (!p_caster) return;
 
    if (getSpellInfo()->getId() == 883)  // "Call Pet" spell
    {
        if (p_caster->getPet() != nullptr)
        {
            sendCastResult(SPELL_FAILED_ALREADY_HAVE_SUMMON);
            return;
        }
 
        const auto foundPetId = p_caster->getPetIdFromSlot(PET_SLOT_FIRST_ACTIVE_SLOT);
        if (foundPetId.has_value())
        {
            const auto petno = foundPetId.value();
            if (p_caster->isPetRequiringTemporaryUnsummon())
            {
#if VERSION_STRING < WotLK
                sendCastResult(SPELL_FAILED_TRY_AGAIN);
#else
                sendCastResult(SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW);
#endif
                return;
            }
 
            if (p_caster->getPetCache(petno) == nullptr)
            {
                sendCastResult(SPELL_FAILED_ALREADY_HAVE_SUMMON);
                return;
            }
 
            if (p_caster->getPetCache(petno)->alive)
            {
                p_caster->spawnPet(petno);
            }
            else
            {
                SendTameFailure(PETTAME_DEAD);
            }
        }
        else
        {
            sendCastResult(SPELL_FAILED_NO_PET);
        }
        return;
    }
 
    //uint32_t entryId = GetProto()->EffectMiscValue[i];
 
    //VoidWalker:torment, sacrifice, suffering, consume shadows
    //Succubus:lash of pain, soothing kiss, seduce , lesser invisibility
    //felhunter:     Devour Magic,Paranoia,Spell Lock,  Tainted Blood
 
    // remove old pet
    Pet* old = p_caster->getPet();
    if (old)
        old->unSummon();
 
    CreatureProperties const* ci = sMySQLStore.getCreatureProperties(getSpellInfo()->getEffectMiscValue(effectIndex));
    if (ci)
    {
        if (p_caster->getClass() == WARLOCK)
        {
            //if demonic sacrifice auras are still active, remove them
            p_caster->removeAllAurasById(18789);
            p_caster->removeAllAurasById(18790);
            p_caster->removeAllAurasById(18791);
            p_caster->removeAllAurasById(18792);
            p_caster->removeAllAurasById(35701);
        }
 
        const auto pet = sObjectMgr.createPet(getSpellInfo()->getEffectMiscValue(effectIndex), nullptr);
        if (!pet->createAsSummon(ci, nullptr, u_caster, u_caster->GetPosition(), 0, m_spellInfo, effectIndex, PET_TYPE_SUMMON))
        {
            pet->DeleteMe();//CreateAsSummon() returns false if an error occurred.
        }
    }
}

Here is the call graph for this function:

◆ spellEffectSummonPlayer()

void Spell::spellEffectSummonPlayer ( uint8_t effectIndex )

◆ SpellEffectSummonPlayer()

void Spell::SpellEffectSummonPlayer ( uint8_t effectIndex )

Definition at line 4782 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget)
        return;
 
    // vojta: from 2.4 players can be summoned on another map
    //if (m_caster->getWorldMap()->GetMapInfo() && m_caster->getWorldMap()->GetMapInfo()->type != INSTANCE_NULL && m_caster->GetMapId() != playerTarget->GetMapId())
    //  return;
    if (m_caster->getWorldMap()->getBaseMap()->getMapInfo() && m_playerTarget->getLevel() < m_caster->getWorldMap()->getBaseMap()->getMapInfo()->minlevel)    // we need some blizzlike message that player needs level xx - feel free to add it ;)
        return;
 
    m_playerTarget->sendSummonRequest(m_caster->getGuidLow(), m_caster->getZoneId(), m_caster->GetMapId(), m_caster->GetInstanceID(), m_caster->GetPosition());
}

Here is the call graph for this function:

◆ SpellEffectSummonPossessed()

void Spell::SpellEffectSummonPossessed	(	uint32_t	i,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

Definition at line 3086 of file SpellEffects.Legacy.cpp.

{
    if (p_caster == nullptr)
        return;
 
    if (p_caster->getPet() != nullptr)
        p_caster->getPet()->unSummon();
 
    v.x += (3 * cos(M_PI_FLOAT / 2 + v.o));
    v.y += (3 * cos(M_PI_FLOAT / 2 + v.o));
 
    Summon* s = p_caster->getWorldMap()->summonCreature(properties_->Id, v, spe, static_cast<uint32_t>(getDuration()), p_caster, m_spellInfo->getId());
    if (s == nullptr)
        return;
 
    p_caster->possess(s, 1000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectSummonPossessed()

void Spell::spellEffectSummonPossessed	(	uint8_t	effectIndex,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

◆ SpellEffectSummonTemporaryPet()

void Spell::SpellEffectSummonTemporaryPet	(	uint32_t	i,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

Definition at line 3043 of file SpellEffects.Legacy.cpp.

{
    if (p_caster == nullptr)
        return;
 
    if (p_caster->getPet() != nullptr)
        p_caster->getPet()->unSummon();
 
    int32_t count = 0;
 
    // Only Inferno uses this SummonProperty ID, and somehow it has the wrong count
    if (spe->ID == 711)
        count = 1;
    else
        count = damage;
 
    // We know for sure that this will suceed because we checked in Spell::SpellEffectSummon
    CreatureProperties const* ci = sMySQLStore.getCreatureProperties(properties_->Id);
 
    float angle_for_each_spawn = -M_PI_FLOAT * 2 / damage;
 
    for (int32_t i = 0; i < count; i++)
    {
        float followangle = angle_for_each_spawn * i;
 
        float x = 3 * (cosf(followangle + u_caster->GetOrientation()));
        float y = 3 * (sinf(followangle + u_caster->GetOrientation()));
 
        v.x += x;
        v.y += y;
 
        const auto pet = sObjectMgr.createPet(properties_->Id, spe);
        if (!pet->createAsSummon(ci, nullptr, p_caster, v, static_cast<uint32_t>(getDuration()), m_spellInfo, i, PET_TYPE_SUMMON))
        {
            pet->DeleteMe();
            break;
        }
 
        // Delay this a bit to make sure its Spawned
        sEventMgr.AddEvent(pet->ToCreature(), &Creature::InitSummon, m_caster, EVENT_UNK, 100, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectSummonTemporaryPet()

void Spell::spellEffectSummonTemporaryPet	(	uint8_t	effectIndex,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

◆ spellEffectSummonTotem()

void Spell::spellEffectSummonTotem	(	uint8_t	effectIndex,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties,
		LocationVector &	v
	)

Definition at line 525 of file SpellEffects.Legacy.cpp.

{
    if (u_caster == nullptr)
        return;
 
    const auto totemSlot = static_cast<SummonSlot>(spe->Slot);
 
    // Generate spawn point
    const float_t angle = totemSlot > SUMMON_SLOT_NONE && totemSlot < SUMMON_SLOT_MINIPET
        ? M_PI_FLOAT / static_cast<float>(SUMMON_SLOT_TOTEM_AIR) - (totemSlot * 2 * M_PI_FLOAT / static_cast<float>(SUMMON_SLOT_TOTEM_AIR))
        : 0.0f;
    u_caster->GetPoint(u_caster->GetOrientation() + angle, 3.5f, v.x, v.y, v.z, false);
 
    // Correct Z position
    //\ todo: this probably should be inside Object::GetPoint()
    const auto landHeight = u_caster->getWorldMap()->getHeight(LocationVector(v.x, v.y, v.z + 2));
    const auto landDiff = landHeight - v.z;
    if (fabs(landDiff) <= 15)
        v.z = landHeight;
 
    auto summonDuration = static_cast<uint32_t>(getDuration());
    if (summonDuration == 0)
        summonDuration = 10 * 60 * 1000; // 10 min if duration does not exist
 
    // Create totem
    const auto totem = u_caster->getWorldMap()->summonCreature(properties->Id, v, spe, summonDuration, u_caster, getSpellInfo()->getId());
    if (totem == nullptr)
        return;
 
    totem->setMaxHealth(damage);
    totem->setHealth(damage);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SpellEffectSummonVehicle()

void Spell::SpellEffectSummonVehicle	(	uint32_t	i,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

Definition at line 3137 of file SpellEffects.Legacy.cpp.

{
    if (u_caster == nullptr)
        return;
 
    // If it has no vehicle id, then we can't really do anything with it as a vehicle :/
    if ((properties_->vehicleid == 0) && (p_caster == nullptr))
        return;
 
    Creature* c = u_caster->getWorldMap()->createCreature(properties_->Id);
    c->Load(properties_, v.x, v.y, v.z, v.o);
    c->setPhase(PHASE_SET, u_caster->GetPhase());
    c->setCreatedBySpellId(m_spellInfo->getId());
    c->setCreatedByGuid(u_caster->getGuid());
    c->setSummonedByGuid(u_caster->getGuid());
    c->removeNpcFlags(UNIT_NPC_FLAG_SPELLCLICK);
    c->PushToWorld(u_caster->getWorldMap());
 
    // Delay this a bit to make sure its Spawned
    sEventMgr.AddEvent(c->ToCreature(), &Creature::InitSummon, m_caster, EVENT_UNK, 100, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
 
#ifdef FT_VEHICLES
    // Need to delay this a bit since first the client needs to see the vehicle
    u_caster->callEnterVehicle(c);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectSummonVehicle()

void Spell::spellEffectSummonVehicle	(	uint8_t	effectIndex,
		WDB::Structures::SummonPropertiesEntry const *	spe,
		CreatureProperties const *	properties_,
		LocationVector &	v
	)

◆ spellEffectSummonWild()

void Spell::spellEffectSummonWild ( uint8_t effectIndex )

◆ SpellEffectSummonWild()

void Spell::SpellEffectSummonWild ( uint8_t effectIndex )

Definition at line 2941 of file SpellEffects.Legacy.cpp.

{
    //these are some creatures that have your faction and do not respawn
    //number of creatures is actually dmg (the usual formula), sometimes =3 sometimes =1
    //if( u_caster == NULL || !u_caster->IsInWorld() )
    //  return;
 
    if ((!m_caster->isGameObject() && !m_caster->isCreatureOrPlayer()) || !m_caster->IsInWorld())
        return;
 
    uint32_t cr_entry = getSpellInfo()->getEffectMiscValue(effectIndex);
    CreatureProperties const* properties = sMySQLStore.getCreatureProperties(cr_entry);
    if (properties == nullptr)
    {
        sLogger.failure("Warning : Missing summon creature template {} used by spell {}!", cr_entry, getSpellInfo()->getId());
        return;
    }
    float x, y, z;
    if (m_targets.hasDestination() && m_targets.getDestination().isSet())
    {
        auto destination = m_targets.getDestination();
        x = destination.x;
        y = destination.y;
        z = destination.z;
    }
    else
    {
        x = m_caster->GetPositionX();
        y = m_caster->GetPositionY();
        z = m_caster->GetPositionZ();
    }
    for (int j = 0; j<damage; j++)
    {
        float m_fallowAngle = -((float(M_PI) / 2) * j);
        float tempx = x + (getEffectRadius(effectIndex) * (cosf(m_fallowAngle + m_caster->GetOrientation())));
        float tempy = y + (getEffectRadius(effectIndex) * (sinf(m_fallowAngle + m_caster->GetOrientation())));
 
        if (Creature* p = m_caster->getWorldMap()->createCreature(cr_entry))
        {
            p->Load(properties, tempx, tempy, z);
            p->setZoneId(m_caster->getZoneId());
 
            if (p->GetCreatureProperties()->Faction == 35)
            {
                if (m_caster->isGameObject())
                    p->setFaction(static_cast<GameObject*>(m_caster)->getFactionTemplate());
                else
                    p->setFaction(static_cast<Unit*>(m_caster)->getFactionTemplate());
            }
            else
            {
                p->setFaction(properties->Faction);
            }
 
            p->setSummonedByGuid(m_caster->getGuid());
            p->setCreatedByGuid(m_caster->getGuid());
 
            p->PushToWorld(m_caster->getWorldMap());
 
            // Delay this a bit to make sure its Spawned
            sEventMgr.AddEvent(p, &Creature::InitSummon, m_caster, EVENT_UNK, 100, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
 
            //make sure they will be desummoned (roxor)
            sEventMgr.AddEvent(p, &Creature::SummonExpire, EVENT_SUMMON_EXPIRE, static_cast<uint32_t>(getDuration()), 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
        }
        else
        {
            sLogger.failure("Spell::SpellEffectSummonWild tried to summon invalid creature {}", cr_entry);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ spellEffectTameCreature()

void Spell::spellEffectTameCreature ( uint8_t effectIndex )

◆ SpellEffectTameCreature()

void Spell::SpellEffectTameCreature ( uint8_t effectIndex )

Definition at line 4165 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || !m_unitTarget->isCreature())
        return;
    if (p_caster == nullptr || p_caster->getPet() != nullptr)
        return;
    Creature* tame = static_cast<Creature*>(m_unitTarget);
 
    // Remove target
    tame->getAIInterface()->handleEvent(EVENT_LEAVECOMBAT, p_caster, 0);
    const auto pet = sObjectMgr.createPet(tame->getEntry(), nullptr);
    if (!pet->createAsSummon(tame->GetCreatureProperties(), tame, p_caster, p_caster->GetPosition(), 0, nullptr, effectIndex, PET_TYPE_HUNTER))
    {
        pet->DeleteMe();//CreateAsSummon() returns false if an error occurred.
    }
    tame->Despawn(0, tame->GetCreatureProperties()->RespawnTime);
}

Here is the call graph for this function:

◆ spellEffectTeachTaxiPath()

void Spell::spellEffectTeachTaxiPath ( uint8_t effectIndex )

◆ SpellEffectTeachTaxiPath()

void Spell::SpellEffectTeachTaxiPath ( uint8_t effectIndex )

Definition at line 6060 of file SpellEffects.Legacy.cpp.

{
    if (!m_playerTarget || !getSpellInfo()->getEffectTriggerSpell(effectIndex))
        return;
 
    uint32_t nodeid = m_spellInfo->getEffectMiscValue(effectIndex);
    if (sTaxiNodesStore.lookupEntry(nodeid))
    {
        m_playerTarget->getSession()->sendDiscoverNewTaxiNode(nodeid);
    }
}

Here is the call graph for this function:

◆ spellEffectTeleportUnits()

void Spell::spellEffectTeleportUnits ( uint8_t effectIndex )

◆ SpellEffectTeleportUnits()

void Spell::SpellEffectTeleportUnits ( uint8_t effectIndex )

Definition at line 1717 of file SpellEffects.Legacy.cpp.

{
    if (m_unitTarget == nullptr || m_caster == nullptr)
        return;
 
    uint32_t spellId = getSpellInfo()->getId();
 
    // Portals
    if (m_spellInfo->hasCustomFlagForEffect(effectIndex, TELEPORT_TO_COORDINATES))
    {
        TeleportCoords const* teleport_coord = sMySQLStore.getTeleportCoord(spellId);
        if (teleport_coord == nullptr)
        {
            sLogger.failure("Spell {} ({}) has a TELEPORT TO COORDINATES effect, but has no coordinates to teleport to. ", spellId, m_spellInfo->getName());
            return;
        }
 
        HandleTeleport(LocationVector(teleport_coord->x, teleport_coord->y, teleport_coord->z), teleport_coord->mapId, m_unitTarget);
        return;
    }
 
    // Hearthstone and co.
    if (m_spellInfo->hasCustomFlagForEffect(effectIndex, TELEPORT_TO_BINDPOINT))
    {
        if (m_unitTarget->isPlayer())
        {
            Player* p = static_cast<Player*>(m_unitTarget);
 
            HandleTeleport(p->getBindPosition(), p->getBindMapId(), p);
        }
        return;
    }
 
    // Summon
    if (m_spellInfo->hasCustomFlagForEffect(effectIndex, TELEPORT_TO_CASTER))
    {
        if (u_caster == nullptr)
            return;
 
        HandleTeleport(m_caster->GetPosition(), m_caster->GetMapId(), m_unitTarget);
        return;
    }
 
    // Shadowstep for example
    if (m_spellInfo->hasCustomFlagForEffect(effectIndex, TELEPORT_BEHIND_TARGET))
    {
        if (p_caster == nullptr)
            return;
 
        ///////////////////////////////////////////////// Code taken from the Shadowstep dummy script /////////////////////////////////////////////////////////////////////
 
        /* this is rather tricky actually. we have to calculate the orientation of the creature/player, and then calculate a little bit of distance behind that. */
        float ang;
 
        if (m_unitTarget == m_caster)
        {
            /* try to get a selection */
            m_unitTarget = m_caster->getWorldMap()->getUnit(m_targets.getUnitTargetGuid());
            if ((!m_unitTarget) || !p_caster->isValidTarget(m_unitTarget, getSpellInfo()) || (m_unitTarget->CalcDistance(p_caster) > 28.0f))
            {
                return;
            }
        }
 
        if (m_unitTarget->isCreature())
        {
            if (m_unitTarget->getTargetGuid() != 0)
            {
                /* We're chasing a target. We have to calculate the angle to this target, this is our orientation. */
                ang = m_caster->calcAngle(m_caster->GetPositionX(), m_caster->GetPositionY(), m_unitTarget->GetPositionX(), m_unitTarget->GetPositionY());
                /* convert degree angle to radians */
                ang = ang * M_PI_FLOAT / 180.0f;
            }
            else
            {
                /* Our orientation has already been set. */
                ang = m_unitTarget->GetOrientation();
            }
        }
        else
        {
            /* Players orientation is sent in movement packets */
            ang = m_unitTarget->GetOrientation();
        }
        // avoid teleporting into the model on scaled models
        const static float shadowstep_distance = 1.6f * m_unitTarget->getScale();
        float new_x = m_unitTarget->GetPositionX() - (shadowstep_distance * cosf(ang));
        float new_y = m_unitTarget->GetPositionY() - (shadowstep_distance * sinf(ang));
        /* Send a movement packet to "charge" at this target. Similar to warrior charge. */
        p_caster->m_zAxisPosition = 0.0f;
        p_caster->safeTeleport(p_caster->GetMapId(), p_caster->GetInstanceID(), LocationVector(new_x, new_y, (m_unitTarget->GetPositionZ() + 0.1f), ang));
 
 
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
        return;
    }
 
    // For those special teleport spells
    if (sScriptMgr.CallScriptedDummySpell(m_spellInfo->getId(), effectIndex, this))
        return;
 
    sLogger.failure("Unhandled Teleport effect Index %hhu for Spell {} ({}).", effectIndex, m_spellInfo->getId(), m_spellInfo->getName());
}

Here is the call graph for this function:

◆ spellEffectThreat()

void Spell::spellEffectThreat ( uint8_t effectIndex )

◆ SpellEffectThreat()

void Spell::SpellEffectThreat ( uint8_t effectIndex )

Definition at line 4382 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !m_unitTarget->isAlive() || !m_unitTarget->isCreature())
        return;
 
    int32_t amount = getSpellInfo()->getEffectBasePoints(effectIndex);
 
    bool chck = m_unitTarget->getThreatManager().getThreat(u_caster);
 
    if (!chck)
    {
        m_unitTarget->getAIInterface()->onHostileAction(u_caster);
        m_unitTarget->getThreatManager().addThreat(u_caster, 0.0f);
    }
    else
        m_unitTarget->getThreatManager().modifyThreatByPercent(u_caster, (int32_t)m_unitTarget->getThreatManager().getThreat(u_caster) * amount / 100);
}

Here is the call graph for this function:

◆ spellEffectTransformItem()

void Spell::spellEffectTransformItem ( uint8_t effectIndex )

◆ SpellEffectTransformItem()

void Spell::SpellEffectTransformItem ( uint8_t effectIndex )

Definition at line 3620 of file SpellEffects.Legacy.cpp.

{
    bool result;
 
    if (!i_caster) return;
    uint32_t itemid = getSpellInfo()->getEffectItemType(effectIndex);
    if (!itemid) return;
 
    //Save durability of the old item
    Player* owner = i_caster->getOwner();
    uint32_t dur = i_caster->getDurability();
 
    result = owner->getItemInterface()->SafeFullRemoveItemByGuid(i_caster->getGuid());
    if (!result)
    {
        //something went wrong if this happen, item doesn't exist, so it wasn't destroyed.
        return;
    }
 
    i_caster = nullptr;
 
    auto it = sObjectMgr.createItem(itemid, owner);
    if (!it) return;
 
    it->setDurability(dur);
    //additem
 
    //additem
    const auto [result2, _] = owner->getItemInterface()->AddItemToFreeSlot(std::move(it));
    if (!result2) //should never get here
    {
        owner->getItemInterface()->buildInventoryChangeError(nullptr, nullptr, INV_ERR_BAG_FULL);
    }
}

Here is the call graph for this function:

◆ spellEffectTriggerMissile()

void Spell::spellEffectTriggerMissile ( uint8_t effectIndex )

◆ SpellEffectTriggerMissile()

void Spell::SpellEffectTriggerMissile ( uint8_t effectIndex )

Definition at line 3337 of file SpellEffects.Legacy.cpp.

{
    //Used by mortar team
    //Triggers area effect spell at destinatiom
 
    uint32_t spellid = getSpellInfo()->getEffectTriggerSpell(effectIndex);
    if (spellid == 0)
    {
        sLogger.failure("Spell {} ({}) has a trigger missle effect index (%hhu) but no trigger spell ID. Spell needs fixing.", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
        return;
    }
 
    SpellInfo const* spInfo = sSpellMgr.getSpellInfo(spellid);
    if (spInfo == nullptr)
    {
        sLogger.failure("Spell {} ({}) has a trigger missle effect index (%hhu) but has an invalid trigger spell ID. Spell needs fixing.", m_spellInfo->getId(), m_spellInfo->getName(), effectIndex);
        return;
    }
 
    // Cast the triggered spell on the destination location, spells like Freezing Arrow use it
    if ((u_caster != nullptr) && (m_targets.hasDestination()))
    {
        u_caster->castSpellLoc(m_targets.getDestination(), spInfo, true);
        return;
    }
 
    float spellRadius = getEffectRadius(effectIndex);
 
    //\todo Following should be / is probably in SpellTarget code
    for (const auto& itr : m_caster->getInRangeObjectsSet())
    {
        if (!itr || !itr->isCreatureOrPlayer() || !static_cast<Unit*>(itr)->isAlive())
            continue;
 
        Unit* t = static_cast<Unit*>(itr);
 
        float r;
        auto destination = m_targets.getDestination();
        float d = destination.x - t->GetPositionX();
        r = d * d;
        d = destination.y - t->GetPositionY();
        r += d * d;
        d = destination.z - t->GetPositionZ();
        r += d * d;
 
        if (std::sqrt(r) > spellRadius) continue;
 
        if (!m_caster->isValidTarget(itr))   //Fix Me: only enemy targets?
            continue;
 
        Spell* sp = sSpellMgr.newSpell(m_caster, spInfo, true, nullptr);
        SpellCastTargets tgt(itr->getGuid());
        sp->prepare(&tgt);
    }
}

Here is the call graph for this function:

◆ spellEffectTriggerSpell()

void Spell::spellEffectTriggerSpell ( uint8_t effectIndex )

Definition at line 630 of file SpellEffects.Legacy.cpp.

{
    const auto triggerInfo = sSpellMgr.getSpellInfo(getSpellInfo()->getEffectTriggerSpell(effectIndex));
    if (triggerInfo == nullptr)
        return;
 
    SpellCastTargets targets = m_targets;
    Spell* triggerSpell = sSpellMgr.newSpell(m_caster, triggerInfo, true, nullptr);
    triggerSpell->ProcedOnSpell = getSpellInfo();
    triggerSpell->prepare(&targets);
}

Here is the call graph for this function:

◆ spellEffectTriggerSpellWithValue()

void Spell::spellEffectTriggerSpellWithValue ( uint8_t effectIndex )

◆ SpellEffectTriggerSpellWithValue()

void Spell::SpellEffectTriggerSpellWithValue ( uint8_t effectIndex )

Definition at line 6013 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget) return;
 
    SpellInfo const* TriggeredSpell = sSpellMgr.getSpellInfo(getSpellInfo()->getEffectTriggerSpell(effectIndex));
    if (TriggeredSpell == nullptr)
        return;
 
    Spell* sp = sSpellMgr.newSpell(m_caster, TriggeredSpell, true, nullptr);
 
    for (uint8_t x = 0; x < 3; x++)
    {
        if (effectIndex == x)
            sp->forced_basepoints->set(x, damage);  //prayer of mending should inherit heal bonus ?
        else
            sp->forced_basepoints->set(x, TriggeredSpell->getEffectBasePoints(effectIndex));
 
    }
 
    SpellCastTargets tgt(m_unitTarget->getGuid());
    sp->prepare(&tgt);
}

Here is the call graph for this function:

◆ spellEffectUseGlyph()

void Spell::spellEffectUseGlyph ( uint8_t effectIndex )

◆ SpellEffectUseGlyph()

void Spell::SpellEffectUseGlyph ( uint8_t effectIndex )

Definition at line 4590 of file SpellEffects.Legacy.cpp.

{
#if VERSION_STRING > TBC
    if (!p_caster)
        return;
 
    if (m_glyphslot >= GLYPHS_COUNT)
        return;
 
    const auto glyphSlot = static_cast<uint16_t>(m_glyphslot);
    uint32_t glyph_new = m_spellInfo->getEffectMiscValue(effectIndex);
    auto glyph_prop_new = sGlyphPropertiesStore.lookupEntry(glyph_new);
    if (!glyph_prop_new)
        return;
 
    // check if glyph is locked (obviously)
    if (!(p_caster->getGlyphsEnabled() & (1 << glyphSlot)))
    {
        sendCastResult(SPELL_FAILED_GLYPH_SOCKET_LOCKED);
        return;
    }
 
    uint32_t glyph_old = p_caster->getGlyph(glyphSlot);
    if (glyph_old)
    {
        if (glyph_old == glyph_new)
        {
            return;
        }
        else
        {
            auto glyph_prop_old = sGlyphPropertiesStore.lookupEntry(glyph_old);
            if (glyph_prop_old)
                p_caster->removeAllAurasById(glyph_prop_old->SpellID);
        }
    }
 
    auto glyph_slot = sGlyphSlotStore.lookupEntry(p_caster->getGlyphSlot(glyphSlot));
    if (glyph_slot)
    {
        if (glyph_slot->Type != glyph_prop_new->Type)
        {
            sendCastResult(SPELL_FAILED_INVALID_GLYPH);
            return;
        }
        p_caster->setGlyph(glyphSlot, glyph_new);
        p_caster->castSpell(p_caster, glyph_prop_new->SpellID, true);
        p_caster->m_specs[p_caster->m_talentActiveSpec].setGlyph(static_cast<uint16_t>(glyph_new), glyphSlot);
        p_caster->smsg_TalentsInfo(false);
    }
#endif
}

Here is the call graph for this function:

◆ spellEffectWeapon()

void Spell::spellEffectWeapon ( uint8_t effectIndex )

Definition at line 558 of file SpellEffects.Legacy.cpp.

{
    if (m_playerTarget == nullptr)
        return;
 
    uint16_t skillId = 0;
    const auto skillLineAbility = sSpellMgr.getFirstSkillEntryForSpell(getSpellInfo()->getId());
    if (skillLineAbility != nullptr)
        skillId = static_cast<uint16_t>(skillLineAbility->skilline);
 
    const auto skillLine = sSkillLineStore.lookupEntry(skillId);
    if (skillLine == nullptr)
        return;
 
    if (!m_playerTarget->hasSkillLine(skillId))
        m_playerTarget->addSkillLine(skillId, 1, 0);
}

Here is the call graph for this function:

◆ spellEffectWeapondamage()

void Spell::spellEffectWeapondamage ( uint8_t effectIndex )

◆ SpellEffectWeapondamage()

void Spell::SpellEffectWeapondamage ( uint8_t effectIndex )

Definition at line 4288 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !u_caster)
        return;
 
    //Hackfix for Mangle
    if (p_caster != nullptr)
    {
        switch (getSpellInfo()->getId())
        {
            case 33876:
            case 33982:
            case 33983:
            case 48565:
            case 48566:
                p_caster->addComboPoints(m_unitTarget->getGuid(), 1);
                break;
        }
    }
 
    // Hacky fix for druid spells where it would "double attack".
    if (getSpellInfo()->getEffect(2) == SPELL_EFFECT_WEAPON_PERCENT_DAMAGE || getSpellInfo()->getEffect(1) == SPELL_EFFECT_WEAPON_PERCENT_DAMAGE)
    {
        add_damage += damage;
        return;
    }
 
    WeaponDamageType _type;
    if (GetType() == SPELL_DMG_TYPE_RANGED)
        _type = RANGED;
    else
    {
        if (hasAttributeExC(ATTRIBUTESEXC_REQUIRES_OFFHAND_WEAPON))
            _type = OFFHAND;
        else
            _type = MELEE;
    }
    m_targetDamageInfo = u_caster->strike(m_unitTarget, _type, getSpellInfo(), damage, 0, 0, m_triggeredSpell, true, isForcedCrit, this);
    isTargetDamageInfoSet = true;
}

Here is the call graph for this function:

◆ spellEffectWeapondamageNoschool()

void Spell::spellEffectWeapondamageNoschool ( uint8_t effectIndex )

◆ SpellEffectWeapondamageNoschool()

void Spell::SpellEffectWeapondamageNoschool ( uint8_t effectIndex )

Definition at line 2411 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !u_caster)
        return;
 
    m_targetDamageInfo = u_caster->strike(m_unitTarget, (GetType() == SPELL_DMG_TYPE_RANGED ? RANGED : MELEE), getSpellInfo(), damage, 0, 0, m_triggeredSpell, true, isForcedCrit, this);
    isTargetDamageInfoSet = true;
}

Here is the call graph for this function:

◆ spellEffectWeaponDmgPerc()

void Spell::spellEffectWeaponDmgPerc ( uint8_t effectIndex )

◆ SpellEffectWeaponDmgPerc()

void Spell::SpellEffectWeaponDmgPerc ( uint8_t effectIndex )

Definition at line 3263 of file SpellEffects.Legacy.cpp.

{
    if (!m_unitTarget || !u_caster) return;
 
    if (GetType() == SPELL_DMG_TYPE_MAGIC)
    {
        auto dmg = CalculateDamage(u_caster, m_unitTarget, MELEE, nullptr, getSpellInfo()) * damage / 100.0f;
 
        // Get bonus damage from spell power and attack power
        if (!isEffectDamageStatic[effectIndex])
            dmg = getUnitCaster()->applySpellDamageBonus(getSpellInfo(), static_cast<int32_t>(dmg), effectPctModifier[effectIndex], false, this);
 
        m_targetDamageInfo = u_caster->doSpellDamage(m_unitTarget, getSpellInfo()->getId(), dmg, effectIndex, m_triggeredSpell, false, false, isForcedCrit, this);
        isTargetDamageInfoSet = true;
    }
    else
    {
        WeaponDamageType _type;
        if (GetType() == SPELL_DMG_TYPE_RANGED)
            _type = RANGED;
        else
        {
            if (getSpellInfo()->getAttributesExC() & ATTRIBUTESEXC_REQUIRES_OFFHAND_WEAPON)
                _type = OFFHAND;
            else
                _type = MELEE;
        }
 
        m_targetDamageInfo = u_caster->strike(m_unitTarget, _type, getSpellInfo(), add_damage, damage, 0, m_triggeredSpell, true, isForcedCrit, this);
        isTargetDamageInfoSet = true;
 
        if (p_caster != nullptr)   // rogue - fan of knives
        {
            switch (getSpellInfo()->getId())
            {
                // SPELL_HASH_FAN_OF_KNIVES
                case 51723:
                case 52874:
                case 61739:
                case 61740:
                case 61741:
                case 61742:
                case 61743:
                case 61744:
                case 61745:
                case 61746:
                case 63753:
                case 65955:
                case 67706:
                case 68097:
                case 68098:
                case 68099:
                case 69921:
                case 71128:
                {
                    Item* oit = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_OFFHAND);
                    if (oit != nullptr)
                    {
                        if (oit->getDurability() != 0)
                        {
                            if (oit->getItemProperties()->Class == 2 && oit->getItemProperties()->SubClass == 15)   // daggers
                                damage = 105; //causing 105% weapon damage with daggers
                            else
                                damage = getSpellInfo()->getEffectBasePoints(effectIndex) + 1;// and 70% weapon damage with all other weapons.
 
                            u_caster->strike(m_unitTarget, OFFHAND, getSpellInfo(), add_damage, damage, 0, m_triggeredSpell, true, isForcedCrit, this);
                        }
                    }
                } break;
            }
        }
    }
}

Here is the call graph for this function:

◆ takePower()

void Spell::takePower ( )

private

Definition at line 5557 of file Spell.cpp.

{
    // Items do not use caster's power and only units have power
    if (i_caster != nullptr || u_caster == nullptr || m_triggeredByAura != nullptr)
        return;
 
    if (p_caster != nullptr && p_caster->m_cheats.hasPowerCheat)
        return;
 
    if (getSpellInfo()->getPowerType() == POWER_TYPE_HEALTH)
    {
        //\ todo: is this correct order?
        u_caster->sendSpellNonMeleeDamageLog(u_caster, u_caster, getSpellInfo(), getPowerCost(), 0, 0, 0, 0, false, false);
        u_caster->dealDamage(u_caster, getPowerCost(), getSpellInfo()->getId(), false);
        return;
    }
#if VERSION_STRING >= WotLK
    else if (getSpellInfo()->getPowerType() == POWER_TYPE_RUNES)
    {
        checkRunes(true);
        return;
    }
#endif
    else if (getSpellInfo()->getPowerType() == POWER_TYPE_MANA && m_powerCost > 0)
    {
        // Start five second timer later at spell cast if spell has a mana cost
        m_usesMana = true;
    }
 
    if (!getSpellInfo()->hasValidPowerType())
    {
        sLogger.failure("Spell::takePower : Unknown power type {} for spell id {}", getSpellInfo()->getPowerType(), getSpellInfo()->getId());
        return;
    }
 
    u_caster->modPower(getSpellInfo()->getPowerType(), -static_cast<int32_t>(m_powerCost));
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ takeUsedSpellModifiers()

void Spell::takeUsedSpellModifiers ( )

Definition at line 5882 of file Spell.cpp.

{
    if (m_usedModifiers.empty())
        return;
 
    for (auto itr = m_usedModifiers.begin(); itr != m_usedModifiers.end();)
    {
        auto aurEff = (*itr).first;
        // Check for faulty entry
        if (aurEff->getAura() == nullptr || (*itr).second)
        {
            itr = m_usedModifiers.erase(itr);
            continue;
        }
 
        aurEff->getAura()->removeCharge();
        itr = m_usedModifiers.erase(itr);
    }
}

Here is the caller graph for this function:

◆ unsetAllTargets()

void Spell::unsetAllTargets ( )

Definition at line 5690 of file Spell.cpp.

{
    m_unitTarget = nullptr;
    m_itemTarget = nullptr;
    m_gameObjTarget = nullptr;
    m_playerTarget = nullptr;
    m_corpseTarget = nullptr;
}

Here is the caller graph for this function:

◆ update()

void Spell::update ( unsigned long timePassed )

\ todo: determine which spells can be cast while moving

Definition at line 1271 of file Spell.cpp.

{
    // Check for moving while casting or channeling
    if (getPlayerCaster() != nullptr && (m_spellState == SPELL_STATE_CASTING || m_spellState == SPELL_STATE_CHANNELING))
    {
        // but allow slight error
        if (u_caster != nullptr &&
            (std::fabs(u_caster->GetPositionX() - m_castPositionX) > 0.5f ||
                std::fabs(u_caster->GetPositionY() - m_castPositionY) > 0.5f ||
                std::fabs(u_caster->GetPositionZ() - m_castPositionZ) > 0.5f))
        {
            // TODO: remove this hackfix when movement is sorted out
            if (m_spellState == SPELL_STATE_CHANNELING && !getSpellInfo()->hasEffectApplyAuraName(SPELL_AURA_MOD_POSSESS))
            {
                // Cancel channeled spells which don't have ATTRIBUTESEXE_CAN_MOVE_WHILE_CHANNELING flag
                if (getSpellInfo()->getChannelInterruptFlags() & CHANNEL_INTERRUPT_ON_MOVEMENT && !(getSpellInfo()->getAttributesExE() & ATTRIBUTESEXE_CAN_MOVE_WHILE_CHANNELING))
                {
                    cancel();
                    return;
                }
            }
            ///\ todo: determine which spells can be cast while moving
            else if (getSpellInfo()->getInterruptFlags() & CAST_INTERRUPT_ON_MOVEMENT)
            {
                // Don't cancel on next melee, autorepeat or triggered spells
                if (!u_caster->hasNoInterrupt() && !m_triggeredSpell && !getSpellInfo()->isOnNextMeleeAttack() && !getSpellInfo()->isRangedAutoRepeat())
                {
                    cancel();
                    return;
                }
            }
        }
    }
 
    switch (m_spellState)
    {
        case SPELL_STATE_CASTING:
        {
            m_timer -= timePassed;
 
            if (m_timer <= 0 && !getSpellInfo()->isOnNextMeleeAttack() && !getSpellInfo()->isRangedAutoRepeat())
            {
                // Skip checks for instant spells
                castMe(m_castTime > 0);
            }
        } break;
        case SPELL_STATE_CHANNELING:
        {
            if (m_timer > 0)
            {
                if (p_caster != nullptr)
                {
                    // Check if channeled spell is cancelled when turning
                    if (m_castPositionO != p_caster->GetOrientation() && getSpellInfo()->getChannelInterruptFlags() & CHANNEL_INTERRUPT_ON_TURNING)
                        cancel();
                }
 
                if (timePassed >= static_cast<uint32_t>(m_timer))
                    m_timer = 0;
                else
                    m_timer -= timePassed;
            }
 
            // Channeling finishes
            if (m_timer == 0)
            {
                sendChannelUpdate(0, timePassed);
                finish();
            }
        } break;
        case SPELL_STATE_TRAVELING:
        {
            for (auto hitItr = m_hitEffects.begin(); hitItr != m_hitEffects.end();)
            {
                auto& hitEff = *hitItr;
                if (hitEff.second.travelTime > timePassed)
                {
                    hitEff.second.travelTime -= timePassed;
                    ++hitItr;
                    continue;
                }
 
                handleHittedEffect(hitEff.first, hitEff.second.effIndex, hitEff.second.damage, true);
                hitItr = m_hitEffects.erase(hitItr);
            }
 
            for (auto missItr = m_missEffects.begin(); missItr != m_missEffects.end();)
            {
                auto& missEff = *missItr;
                if (missEff.second.travelTime > timePassed)
                {
                    missEff.second.travelTime -= timePassed;
                    ++missItr;
                    continue;
                }
 
                handleMissedEffect(missEff.second.missInfo, true);
                missItr = m_missEffects.erase(missItr);
            }
 
            for (auto auraItr = m_pendingAuras.begin(); auraItr != m_pendingAuras.end();)
            {
                auto& auraEff = *auraItr;
                if (auraEff.second.travelTime > timePassed)
                {
                    auraEff.second.travelTime -= timePassed;
                    ++auraItr;
                    continue;
                }
 
                HandleAddAura(auraEff.first);
                auraItr = m_pendingAuras.erase(auraItr);
            }
 
            // If all effects and targets have been processed, finish the spell
            if (m_hitEffects.empty() && m_missEffects.empty() && m_pendingAuras.empty())
                finish();
        } break;
        default:
            break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wasCastedinDuel()

bool Spell::wasCastedinDuel ( ) const

Definition at line 5659 of file Spell.cpp.

{
    return duelSpell;
}

Here is the caller graph for this function:

◆ writeProjectileDataToPacket()

void Spell::writeProjectileDataToPacket ( WorldPacket * data )

private

Definition at line 5405 of file Spell.cpp.

{
    ItemProperties const* ammoItem = nullptr;
#if VERSION_STRING < Cata
    if (p_caster != nullptr)
    {
        const auto rangedItem = p_caster->getItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_RANGED);
        if (rangedItem != nullptr)
        {
            if (getSpellInfo()->getId() == SPELL_RANGED_THROW)
            {
                ammoItem = rangedItem->getItemProperties();
            }
            else
            {
                if (p_caster->getAmmoId() != 0)
                {
                    ammoItem = sMySQLStore.getItemProperties(p_caster->getAmmoId());
                }
                else
                {
                    // Use Rough Arrow if ammo id is not found
                    ammoItem = sMySQLStore.getItemProperties(2512);
                }
            }
        }
    }
    else if (u_caster != nullptr)
    {
        // Get creature's ranged weapon
        // Need to loop through all weapon slots because NPCs can have the ranged weapon in main hand
        for (uint8_t i = 0; i <= RANGED; ++i)
        {
#if VERSION_STRING > TBC
            const auto entryId = u_caster->getVirtualItemSlotId(i);
#else
            const auto entryId = dynamic_cast<Creature*>(u_caster)->getVirtualItemEntry(i);
#endif
            if (entryId == 0)
                continue;
 
#if VERSION_STRING > TBC
            // Get the item data from DBC files
            const auto itemDBC = sItemStore.lookupEntry(entryId);
            if (itemDBC == nullptr || itemDBC->Class != ITEM_CLASS_WEAPON)
                continue;
 
            switch (itemDBC->SubClass)
            {
                case ITEM_SUBCLASS_WEAPON_BOW:
                case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                    // Use Rough Arrow for bows
                    ammoItem = sMySQLStore.getItemProperties(2512);
                    break;
                case ITEM_SUBCLASS_WEAPON_GUN:
                    // Use Light Shot for guns
                    ammoItem = sMySQLStore.getItemProperties(2516);
                    break;
                case ITEM_SUBCLASS_WEAPON_THROWN:
                    ammoItem = sMySQLStore.getItemProperties(entryId);
                    break;
                default:
                    break;
            }
#else
            // Get the item data from unitdata
            const auto itemData = u_caster->getVirtualItemInfoFields(i);
            if (itemData.fields.item_class != ITEM_CLASS_WEAPON)
                continue;
 
            switch (itemData.fields.item_subclass)
            {
                case ITEM_SUBCLASS_WEAPON_BOW:
                case ITEM_SUBCLASS_WEAPON_CROSSBOW:
                    // Use Rough Arrow for bows
                    ammoItem = sMySQLStore.getItemProperties(2512);
                    break;
                case ITEM_SUBCLASS_WEAPON_GUN:
                    // Use Light Shot for guns
                    ammoItem = sMySQLStore.getItemProperties(2516);
                    break;
                case ITEM_SUBCLASS_WEAPON_THROWN:
                    ammoItem = sMySQLStore.getItemProperties(entryId);
                    break;
                default:
                    break;
            }
#endif
 
            // No need to continue if ammo has been found
            if (ammoItem != nullptr)
                break;
        }
    }
#endif
 
    if (ammoItem != nullptr)
    {
        *data << uint32_t(ammoItem->DisplayInfoID);
        *data << uint32_t(ammoItem->InventoryType);
    }
#if VERSION_STRING > TBC
    else
    {
        *data << uint32_t(0);
        *data << uint32_t(0);
    }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ writeSpellMissedTargets()

void Spell::writeSpellMissedTargets ( WorldPacket * data )

private

Definition at line 5515 of file Spell.cpp.

{
    if (u_caster != nullptr && u_caster->isAlive())
    {
        for (const auto& target : m_missedTargets)
        {
            *data << uint64_t(target.targetGuid);
            *data << uint8_t(target.hitResult);
            // Need to send hit result for the reflected spell
            if (target.hitResult == SPELL_DID_HIT_REFLECT)
                *data << uint8_t(target.extendedHitResult);
        }
    }
    else
    {
        for (const auto& target : m_missedTargets)
        {
            *data << uint64_t(target.targetGuid);
            *data << uint8_t(target.hitResult);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ DummySpellHandler

friend class DummySpellHandler

friend

Definition at line 481 of file Spell.hpp.

◆ DynamicObject

friend class DynamicObject

friend

Definition at line 726 of file Spell.hpp.

Member Data Documentation

◆ add_damage

uint32_t Spell::add_damage

protected

Definition at line 712 of file Spell.hpp.

◆ cancastresult

SpellCastResult Spell::cancastresult = SPELL_CAST_SUCCESS

private

Definition at line 337 of file Spell.hpp.

◆ castedItemId

uint32_t Spell::castedItemId

Definition at line 684 of file Spell.hpp.

◆ chaindamage

uint32_t Spell::chaindamage

Definition at line 665 of file Spell.hpp.

◆ damage

int32_t Spell::damage

Definition at line 679 of file Spell.hpp.

◆ damageToHit

int32_t Spell::damageToHit

Definition at line 683 of file Spell.hpp.

◆ duelSpell

bool Spell::duelSpell = false

protected

Definition at line 160 of file Spell.hpp.

◆ effectPctModifier

float_t Spell::effectPctModifier[MAX_SPELL_EFFECTS]

private

Definition at line 332 of file Spell.hpp.

◆ extra_cast_number

uint8_t Spell::extra_cast_number

Definition at line 685 of file Spell.hpp.

bool Spell::isTargetDamageInfoSet = false

private

Definition at line 314 of file Spell.hpp.

private

Definition at line 305 of file Spell.hpp.

◆ m_effectRadius

float_t Spell::m_effectRadius[MAX_SPELL_EFFECTS] = { 0.0f }

private

Definition at line 308 of file Spell.hpp.

308{ 0.0f };

◆ m_effectTargets

std::vector<uint64_t> Spell::m_effectTargets[MAX_SPELL_EFFECTS]

private

Definition at line 199 of file Spell.hpp.

◆ m_gameObjTarget

GameObject* Spell::m_gameObjTarget = nullptr

private

Definition at line 206 of file Spell.hpp.

◆ m_glyphslot

uint32_t Spell::m_glyphslot

Definition at line 686 of file Spell.hpp.

◆ m_hitEffects

std::map<uint64_t, HitSpellEffect> Spell::m_hitEffects

private

Definition at line 326 of file Spell.hpp.

◆ m_IsCastedOnSelf

bool Spell::m_IsCastedOnSelf

protected

Definition at line 708 of file Spell.hpp.

◆ m_isEffectRadiusSet

bool Spell::m_isEffectRadiusSet[MAX_SPELL_EFFECTS] = { false }

private

Definition at line 309 of file Spell.hpp.

309{ false };

◆ m_itemTarget

Item* Spell::m_itemTarget = nullptr

private

Definition at line 205 of file Spell.hpp.

◆ m_magnetTarget

uint64_t Spell::m_magnetTarget

protected

Definition at line 710 of file Spell.hpp.

◆ m_missedTargets

std::vector<SpellTargetMod> Spell::m_missedTargets

private

Definition at line 197 of file Spell.hpp.

◆ m_missEffects

std::map<uint64_t, MissSpellEffect> Spell::m_missEffects

private

Definition at line 327 of file Spell.hpp.

◆ m_missilePitch

float Spell::m_missilePitch

Definition at line 721 of file Spell.hpp.

bool Spell::m_Spell_Failed

uint32_t Spell::m_targetProcFlags = 0

private

Definition at line 316 of file Spell.hpp.

SpellInfo const* Spell::ProcedOnSpell

Definition at line 534 of file Spell.hpp.

◆ pSpellId

uint32_t Spell::pSpellId

Definition at line 533 of file Spell.hpp.

◆ u_caster

Unit* Spell::u_caster = nullptr

protected

Definition at line 163 of file Spell.hpp.

The documentation for this class was generated from the following files:

AscEmu/src/world/Spell/Spell.hpp
AscEmu/src/world/Spell/Spell.cpp
AscEmu/src/world/Spell/Spell.Legacy.cpp
AscEmu/src/world/Spell/SpellEffects.Legacy.cpp
AscEmu/src/world/Spell/SpellTarget.Legacy.cpp

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ Spell()

◆ ~Spell()

Member Function Documentation

◆ _getSpellTravelTimeForTarget()

◆ _loadInitialTargetPointers()

◆ _prepareProcFlags()

◆ _updateCasterPointers()

◆ _updateTargetPointers()

◆ AddAOETargets()

◆ AddChainTargets()

◆ AddConeTargets()

◆ AddPartyTargets()

◆ AddRaidTargets()

◆ AddScriptedOrSpellFocusTargets()

◆ AddTarget()

◆ AddTime()

◆ addUsedSpellModifier()

◆ ApplyAreaAura()

◆ calculateEffect()

◆ calculateJumpSpeeds()

◆ calculatePowerCost()

◆ canAttackCreatureType()

◆ CanCast()

◆ canCast()

◆ cancel()

◆ castMe()

◆ castMeOld()

◆ checkCasterState()

◆ checkExplicitTarget()

◆ checkItems()

◆ checkPower()

◆ checkRange()

◆ checkRunes()

◆ checkShapeshift()

◆ CreateItem()

◆ DetermineSkillUp() [1/3]

◆ DetermineSkillUp() [2/3]

◆ DetermineSkillUp() [3/3]

◆ DidHit()

◆ DoAfterHandleEffect()

◆ DoCalculateEffect()

◆ DuelSpellNoMoreValid()

◆ FillAllFriendlyInArea()

◆ FillAllTargetsInArea() [1/3]

◆ FillAllTargetsInArea() [2/3]

◆ FillAllTargetsInArea() [3/3]

◆ FillSpecifiedTargetsInArea() [1/2]

◆ FillSpecifiedTargetsInArea() [2/2]

◆ FillTargetMap()

◆ finish()

◆ GenerateTargets()

◆ GetBaseThreat()

◆ getCaster()

◆ getCastTimeLeft()

◆ getCorpseTarget()

◆ getDestination()

◆ getDuration()

◆ getEffectRadius()

◆ getFullCastTime()

◆ getGameObjectCaster()

◆ getGameObjectTarget()

◆ getItemCaster()

◆ getItemTarget()

◆ GetMechanic()

◆ getPlayerCaster()

◆ getPlayerTarget()

◆ getPowerCost()

◆ GetSinglePossibleEnemy()

◆ GetSinglePossibleFriend()